线程同步
线程同步：
现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来。
处理多线程问题时，多个线程访问同一个资源对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
- 由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起；
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和 调度延时，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级导致，引起性能问题。
多线程不安全案例一：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 不安全的买票 6 * <p> 7 * 线程不安全，有可能有的人拿到负数票 8 * version: 1.0 9 */ 10 public class UnsafeBuyTicket { 11 12 public static void main(String[] args) { 13 BuyTicket station = new BuyTicket(); 14 15 new Thread(station, "我").start(); 16 new Thread(station, "你").start(); 17 new Thread(station, "黄牛党").start(); 18 } 19 } 20 21 class BuyTicket implements Runnable { 22 23 //票 24 private int ticketNums = 10; 25 boolean flag = true;//外部停止方式 26 27 @Override 28 public void run() { 29 //买票 30 while (flag) { 31 try { 32 buy(); 33 } catch (InterruptedException e) { 34 e.printStackTrace(); 35 } 36 } 37 } 38 39 private void buy() throws InterruptedException { 40 //判断是否有票 41 if (ticketNums <= 0) { 42 flag = false; 43 return; 44 } 45 //模拟延时 46 Thread.sleep(100); 47 //买票 48 System.out.println(Thread.currentThread().getName() + "拿到" + (ticketNums--)); 49 } 50 }
运行结果：
多线程不安全案例二：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 不安全取钱 6 * <p> 7 * 两个人去银行取现，账户 8 * version: 1.0 9 */ 10 public class UnsafeBank { 11 public static void main(String[] args) { 12 //账户 13 Account account = new Account(100, "结婚基金"); 14 15 Drawing you = new Drawing(account, 50, "你"); 16 Drawing girlFriend = new Drawing(account, 100, "girlFriend"); 17 18 you.start(); 19 girlFriend.start(); 20 } 21 } 22 23 //账户 24 class Account { 25 double money;//余额 26 String name;//卡名 27 28 public Account(double money, String name) { 29 this.money = money; 30 this.name = name; 31 } 32 } 33 34 //银行：模拟取款 35 class Drawing extends Thread { 36 Account account;//账户 37 //取了多少钱 38 double drawingMoney; 39 //现在手里有多少钱 40 double nowMoney; 41 42 public Drawing(Account account, double drawingMoney, String name) { 43 super(name); 44 this.account = account; 45 this.drawingMoney = drawingMoney; 46 } 47 48 //取钱 49 @Override 50 public void run() { 51 //判断有没有钱 52 if (account.money - drawingMoney < 0) { 53 System.out.println(Thread.currentThread().getName() + "钱不够，取不了"); 54 return; 55 } 56 57 //sleep可以放大问题的发生性 58 try { 59 Thread.sleep(1000); 60 } catch (InterruptedException e) { 61 e.printStackTrace(); 62 } 63 64 //卡内余额 = 余额 - 你取的钱 65 account.money = account.money - drawingMoney; 66 //你手里的钱 67 nowMoney = nowMoney + drawingMoney; 68 69 System.out.println(account.name + "余额为：" + account.money); 70 //Thread.currentThread().getName() 等价于 this.getName() 71 System.out.println(this.getName() + "手里的钱：" + nowMoney); 72 } 73 }
运行结果：
多线程不安全案例三：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /** 7 * Created by 火龙裸 on 2019/11/9. 8 * desc : 线程不安全的集合 9 * version: 1.0 10 */ 11 public class UnsafeList { 12 public static void main(String[] args) { 13 14 final List<String> list = new ArrayList<>(); 15 for (int i = 0; i < 10000; i++) { 16 new Thread(new Runnable() { 17 @Override 18 public void run() { 19 list.add(Thread.currentThread().getName()); 20 } 21 }).start(); 22 } 23 24 System.out.println(list.size()); 25 } 26 }
运行结果：
可以看出，本来按照预期应该是9999，但是却只有9998。所以说ArrayList是不安全的。
为了避免消耗不必要的性能，提高效率，一般在方法里面，需要修改的内容才需要锁，锁的太多，浪费资源。比如代码中有些只读、有些只写，那么只需要对负责“只写”的那个代码块进行加锁就行。
代码示例：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 不安全的买票 6 * version: 1.0 7 */ 8 public class UnsafeBuyTicket { 9 10 public static void main(String[] args) { 11 BuyTicket station = new BuyTicket(); 12 13 new Thread(station, "我").start(); 14 new Thread(station, "你").start(); 15 new Thread(station, "黄牛党").start(); 16 } 17 } 18 19 class BuyTicket implements Runnable { 20 21 //票 22 private int ticketNums = 10; 23 boolean flag = true;//外部停止方式 24 25 @Override 26 public void run() { 27 //买票 28 while (flag) { 29 try { 30 buy(); 31 } catch (InterruptedException e) { 32 e.printStackTrace(); 33 } 34 } 35 } 36 37 //synchronized 同步方法，锁的是this 38 private synchronized void buy() throws InterruptedException { 39 //判断是否有票 40 if (ticketNums <= 0) { 41 flag = false; 42 return; 43 } 44 //模拟延时 45 Thread.sleep(100); 46 //买票 47 System.out.println(Thread.currentThread().getName() + "拿到" + (ticketNums--)); 48 } 49 }
运行结果：
再来第二个案例：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 不安全取钱 6 * <p> 7 * 两个人去银行取现，账户 8 * version: 1.0 9 */ 10 public class UnsafeBank { 11 public static void main(String[] args) { 12 //账户 13 Account account = new Account(100, "结婚基金"); 14 15 Drawing you = new Drawing(account, 50, "你"); 16 Drawing girlFriend = new Drawing(account, 100, "girlFriend"); 17 18 you.start(); 19 girlFriend.start(); 20 } 21 } 22 23 //账户 24 class Account { 25 double money;//余额 26 String name;//卡名 27 28 public Account(double money, String name) { 29 this.money = money; 30 this.name = name; 31 } 32 } 33 34 //银行：模拟取款 35 class Drawing extends Thread { 36 Account account;//账户 37 //取了多少钱 38 double drawingMoney; 39 //现在手里有多少钱 40 double nowMoney; 41 42 public Drawing(Account account, double drawingMoney, String name) { 43 super(name); 44 this.account = account; 45 this.drawingMoney = drawingMoney; 46 } 47 48 //取钱 49 @Override 50 public synchronized void run() { 51 //判断有没有钱 52 if (account.money - drawingMoney < 0) { 53 System.out.println(Thread.currentThread().getName() + "钱不够，取不了"); 54 return; 55 } 56 57 //sleep可以放大问题的发生性 58 try { 59 Thread.sleep(1000); 60 } catch (InterruptedException e) { 61 e.printStackTrace(); 62 } 63 64 //卡内余额 = 余额 - 你取的钱 65 account.money = account.money - drawingMoney; 66 //你手里的钱 67 nowMoney = nowMoney + drawingMoney; 68 69 System.out.println(account.name + "余额为：" + account.money); 70 //Thread.currentThread().getName() 等价于 this.getName() 71 System.out.println(this.getName() + "手里的钱：" + nowMoney); 72 } 73 }
这个代码中，synchronized添加到了run方法位置处了，很明显无效。因为这里锁run方法，synchronized默认锁的是this对象，也就是它本身，放在这里也就是锁的是Drawing对象（银行）。但是我们操作的“增删改”的对象不是银行，而是账户account对象。用account作为同步监视器，所以这个时候需要用锁代码块。把涉及到“写”操作的代码都丢到块里面就行。如下：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 安全取钱 6 * <p> 7 * 两个人去银行取现，账户 8 * version: 1.0 9 */ 10 public class UnsafeBank { 11 public static void main(String[] args) { 12 //账户 13 Account account = new Account(1000, "结婚基金"); 14 15 Drawing you = new Drawing(account, 50, "你"); 16 Drawing girlFriend = new Drawing(account, 100, "girlFriend"); 17 18 you.start(); 19 girlFriend.start(); 20 } 21 } 22 23 //账户 24 class Account { 25 double money;//余额 26 String name;//卡名 27 28 public Account(double money, String name) { 29 this.money = money; 30 this.name = name; 31 } 32 } 33 34 //银行：模拟取款 35 class Drawing extends Thread { 36 Account account;//账户 37 //取了多少钱 38 double drawingMoney; 39 //现在手里有多少钱 40 double nowMoney; 41 42 public Drawing(Account account, double drawingMoney, String name) { 43 super(name); 44 this.account = account; 45 this.drawingMoney = drawingMoney; 46 } 47 48 //取钱 49 @Override 50 public void run() { 51 //锁的对象应该是变化的量，需要增删改的对象，这里就是account。 52 synchronized (account) { 53 //判断有没有钱 54 if (account.money - drawingMoney < 0) { 55 System.out.println(Thread.currentThread().getName() + "钱不够，取不了"); 56 return; 57 } 58 59 //sleep可以放大问题的发生性 60 try { 61 Thread.sleep(1000); 62 } catch (InterruptedException e) { 63 e.printStackTrace(); 64 } 65 66 //卡内余额 = 余额 - 你取的钱 67 account.money = account.money - drawingMoney; 68 //你手里的钱 69 nowMoney = nowMoney + drawingMoney; 70 71 System.out.println(account.name + "余额为：" + account.money); 72 //Thread.currentThread().getName() 等价于 this.getName() 73 System.out.println(this.getName() + "手里的钱：" + nowMoney); 74 } 75 } 76 }
运行结果：
再来第三个案例：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /** 7 * Created by 火龙裸 on 2019/11/9. 8 * desc : 线程不安全的集合 变成 安全 9 * version: 1.0 10 */ 11 public class UnsafeList { 12 public static void main(String[] args) { 13 14 final List<String> list = new ArrayList<>(); 15 for (int i = 0; i < 10000; i++) { 16 new Thread(new Runnable() { 17 @Override 18 public void run() { 19 //将list这个涉及到写操作的对象作为同步监视器 20 synchronized (list) { 21 list.add(Thread.currentThread().getName()); 22 } 23 } 24 }).start(); 25 } 26 27 System.out.println(list.size()); 28 } 29 }
运行结果：
小结：
死锁：
- 多个线程各自占用一些共享资源对象，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
代码示例：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 死锁：多个线程互相抱着对方需要的资源，然后形成僵持。 6 * version: 1.0 7 */ 8 public class DeadLock { 9 public static void main(String[] args) { 10 MakeUp g1 = new MakeUp(0, "灰姑娘"); 11 MakeUp g2 = new MakeUp(1, "白雪公主"); 12 13 g1.start(); 14 g2.start(); 15 } 16 } 17 18 //口红 19 class Lipstick { 20 21 } 22 23 //镜子 24 class Mirror { 25 26 } 27 28 class MakeUp extends Thread { 29 30 //需要的资源只有一份，用static来保证只有一份 31 static Lipstick lipstick = new Lipstick(); 32 static Mirror mirror = new Mirror(); 33 34 int choice;//选择 35 String girlName;//使用化妆品的人 36 37 public MakeUp(int choice, String girlName) { 38 this.choice = choice; 39 this.girlName = girlName; 40 } 41 42 @Override 43 public void run() { 44 //化妆 45 try { 46 makeUp(); 47 } catch (InterruptedException e) { 48 e.printStackTrace(); 49 } 50 } 51 52 //化妆，互相持有对象的锁，就是需要拿到对方的资源 53 private void makeUp() throws InterruptedException { 54 if (choice == 0) { 55 synchronized (lipstick) {//获得口红的锁 56 System.out.println(this.getName() + "获得口红的锁"); 57 Thread.sleep(1000); 58 59 synchronized (mirror) {//一秒钟后想获得镜子 60 System.out.println(this.getName() + "获得镜子的锁"); 61 } 62 } 63 } else { 64 synchronized (mirror) {//获得镜子的锁 65 System.out.println(this.getName() + "获得镜子的锁"); 66 Thread.sleep(2000); 67 68 synchronized (lipstick) {//一秒钟后想获得口红 69 System.out.println(this.getName() + "获得口红的锁"); 70 } 71 } 72 } 73 } 74 }
运行结果（代码中，一个人获得了口红的锁，想获得镜子的锁，一个人拿到了镜子的锁，想获得口红的锁，互相僵持。直接卡死在这个位置不动了！）：
解决方式如下（直接把锁拿出来）：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 死锁：多个线程互相抱着对方需要的资源，然后形成僵持。 6 * version: 1.0 7 */ 8 public class DeadLock { 9 public static void main(String[] args) { 10 MakeUp g1 = new MakeUp(0, "灰姑娘"); 11 MakeUp g2 = new MakeUp(1, "白雪公主"); 12 13 g1.start(); 14 g2.start(); 15 } 16 } 17 18 //口红 19 class Lipstick { 20 21 } 22 23 //镜子 24 class Mirror { 25 26 } 27 28 class MakeUp extends Thread { 29 30 //需要的资源只有一份，用static来保证只有一份 31 static Lipstick lipstick = new Lipstick(); 32 static Mirror mirror = new Mirror(); 33 34 int choice;//选择 35 String girlName;//使用化妆品的人 36 37 public MakeUp(int choice, String girlName) { 38 this.choice = choice; 39 this.girlName = girlName; 40 } 41 42 @Override 43 public void run() { 44 //化妆 45 try { 46 makeUp(); 47 } catch (InterruptedException e) { 48 e.printStackTrace(); 49 } 50 } 51 52 //化妆，互相持有对象的锁，就是需要拿到对方的资源 53 private void makeUp() throws InterruptedException { 54 if (choice == 0) { 55 synchronized (lipstick) {//获得口红的锁 56 System.out.println(this.getName() + "获得口红的锁"); 57 Thread.sleep(1000); 58 } 59 synchronized (mirror) {//一秒钟后想获得镜子 60 System.out.println(this.getName() + "获得镜子的锁"); 61 } 62 } else { 63 synchronized (mirror) {//获得镜子的锁 64 System.out.println(this.getName() + "获得镜子的锁"); 65 Thread.sleep(2000); 66 } 67 synchronized (lipstick) {//一秒钟后想获得口红 68 System.out.println(this.getName() + "获得口红的锁"); 69 } 70 } 71 } 72 }
运行结果：
小结：
Lock显式锁：
代码示例（不安全写法）：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 /** 4 * Created by 火龙裸 on 2019/11/9. 5 * desc : 测试Lock锁 6 * version: 1.0 7 */ 8 public class TestLock { 9 public static void main(String[] args) { 10 TestLock2 testLock2 = new TestLock2(); 11 12 new Thread(testLock2).start(); 13 new Thread(testLock2).start(); 14 new Thread(testLock2).start(); 15 } 16 } 17 18 class TestLock2 implements Runnable { 19 20 int ticketNums = 5; 21 22 @Override 23 public void run() { 24 while (true) { 25 if (ticketNums > 0) { 26 try { 27 Thread.sleep(1000); 28 } catch (InterruptedException e) { 29 e.printStackTrace(); 30 } 31 System.out.println(ticketNums--); 32 } else { 33 break; 34 } 35 } 36 } 37 }
运行结果：
代码示例（安全写法）：
1 package com.huolongluo.coindemo.morethread.sub3; 2 3 import java.util.concurrent.locks.ReentrantLock; 4 5 /** 6 * Created by 火龙裸 on 2019/11/9. 7 * desc : 测试Lock锁 8 * version: 1.0 9 */ 10 public class TestLock { 11 public static void main(String[] args) { 12 TestLock2 testLock2 = new TestLock2(); 13 14 new Thread(testLock2).start(); 15 new Thread(testLock2).start(); 16 new Thread(testLock2).start(); 17 } 18 } 19 20 class TestLock2 implements Runnable { 21 22 int ticketNums = 5; 23 24 //定义Lock锁，Lock是一个接口，ReentrantLock实现了该接口 25 private final ReentrantLock reentrantLock = new ReentrantLock();//可重入锁 26 27 28 @Override 29 public void run() { 30 while (true) { 31 reentrantLock.lock();//加锁 32 try { 33 if (ticketNums > 0) { 34 try { 35 Thread.sleep(1000); 36 } catch (InterruptedException e) { 37 e.printStackTrace(); 38 } 39 System.out.println(ticketNums--); 40 } else { 41 break; 42 } 43 } finally { 44 reentrantLock.unlock();//解锁 45 } 46 } 47 } 48 }
运行结果：
总结：
