[关闭]
@lemonguge 2015-07-07T01:23:37.000000Z 字数 9167 阅读 374

并发性和多线程（三）

Concurrency

对于上一篇文章所遗留的问题，也就是笔者即将进行介绍的内容。

wait(),notify()和notifyAll()

在第一篇介绍多线程的状态时，笔者曾经提到过这三个方法。这三个方法都是监视器的方法，在之前的同步块中，说过：“在同步块中，我们也把锁称为监视器对象。”

wait()方法和sleep()方法都可以使当前线程从运行状态变为冻结状态。注意，wait()方法会同时释放执行权和释放锁，sleep()方法释放执行权不释放锁。这句话很容易理解，如果不是释放执行权，将相当与CPU一直等待，这种现象会使电脑死机的；如果wait()方法不释放锁，由于需要被其他线程唤醒，其他线程如果拿不到锁的话那就不能被唤醒了。

notify()方法和notifyAll()方法是用来唤醒线程的。在此，重复一遍：“notify()唤醒该监视器所监视的处于冻结状态的所有线程的任意一个线程，notifyAll()唤醒该监视器所监视的所有冻结线程。”

清楚了上面介绍的这三个方法，我们可以对之前的问题进行解决。当烤鸭店生产了一只烤鸭后，便通过监视器唤醒消费者“哥们，烤鸭做好啦，过来吃”，同时使烤鸭店处于等待状态，只要消费者消费了一只烤鸭，那么监视器便唤醒烤鸭店“老板，我吃完啦，再来一只”，同时使消费者处于等待状态。

  1. import java.io.BufferedOutputStream;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.PrintStream;
  6. // 资源代表烤鸭
  7. class Resource{
  8.     boolean flag; // 通过标志位判断烤鸭是否做好了
  9. }
  10. // 生产者代表餐厅
  11. class Producer implements Runnable{
  12.     private Resource res;
  13.     public Producer(Resource res) {
  14.         this.res = res;
  15.     }
  16.     @Override
  17.     public void run() {
  18.         while (true)
  19.             synchronized (res) { // 临界区
  20.                 if (!res.flag) {
  21.                     System.out.println("Producer run..");
  22.                     res.flag = true;
  23.                     res.notify(); // 唤醒消费者，烤鸭做好啦
  24.                     try { // 会出现中断异常，由于异常限制，只能捕获不能声明
  25.                         res.wait(); // 使当前线程等待，即烤鸭刚做好，等着消费
  26.                     } catch (InterruptedException e) {
  27.                         e.printStackTrace();
  28.                     }
  29.                 } else {
  30.                     System.out.println("Resource exist!");
  31.                 }
  32.             }
  33.     }
  34. }
  35. // 消费者
  36. class Consumer implements Runnable{
  37.     private Resource res;
  38.     public Consumer(Resource res) {
  39.         this.res = res;
  40.     }
  41.     @Override
  42.     public void run() {
  43.         while (true)
  44.             synchronized (res) { // 临界区
  45.                 if (res.flag) {
  46.                     System.out.println("Consumer eat..");
  47.                     res.flag = false;
  48.                     res.notify(); // 唤醒烤鸭店，烤鸭吃完啦
  49.                     try {
  50.                         res.wait(); // 刚刚消费烤鸭，烤鸭没做好呢，继续等待
  51.                     } catch (Exception e) {
  52.                         e.printStackTrace();
  53.                     }
  54.                 } else {
  55.                     System.out.println("Waitting Resource!");
  56.                 }
  57.             }
  58.     }
  59. }
  60. public class OneToOne {
  61.     public static void main(String[] args) throws InterruptedException {
  62.         PrintStream ps = logger();
  63.         Resource res = new Resource();
  64.         Producer pro = new Producer(res);
  65.         Consumer con = new Consumer(res);
  66.         Thread t1 = new Thread(pro,"生产者");
  67.         Thread t2 = new Thread(con,"消费者");
  68.         t1.start();
  69.         t2.start();
  70.         Thread.sleep(250);
  71.         ps.close();
  72.     }
  74.     public static PrintStream logger(){
  75.         PrintStream ps = null;
  76.         try {
  77.             ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("log.txt")),true);
  78.         } catch (FileNotFoundException e) {
  79.             e.printStackTrace();
  80.         }
  81.         System.setOut(ps);
  82.         return ps;
  83.     }
  84. } /* Output:
  85. Producer run..
  86. Consumer eat..
  87. Producer run..
  88. Consumer eat..
  89. ...
  90. *///:~

输出结果符合我们的期望，通过上面的示例，相信大家清楚了这三个方法的使用。接下来，我们对上面的代码进行些修改和简化，虽然功能是相同，但是之后会演示一个现象。

  1. import java.io.BufferedOutputStream;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.PrintStream;
  6. // 资源代表烤鸭
  7. class Resource{
  8.     boolean flag; // 通过标志位判断烤鸭是否做好了
  9. }
  10. // 生产者代表餐厅
  11. class Producer implements Runnable{
  12.     private Resource res;
  13.     public Producer(Resource res) {
  14.         this.res = res;
  15.     }
  16.     @Override
  17.     public void run() {
  18.         while (true)
  19.             synchronized (res) { // 临界区
  20.                 if (res.flag)
  21.                     try { res.wait(); } catch (InterruptedException e) { }
  22.                 System.out.println(Thread.currentThread().getName() + "@Producer run..");
  23.                 res.flag = true;
  24.                 res.notify(); // 唤醒消费者，烤鸭做好啦
  25.             }
  26.     }
  27. }
  28. // 消费者
  29. class Consumer implements Runnable{
  30.     private Resource res;
  31.     public Consumer(Resource res) {
  32.         this.res = res;
  33.     }
  34.     @Override
  35.     public void run() {
  36.         while (true)
  37.             synchronized (res) { // 临界区
  38.                 if (!res.flag)
  39.                     try { res.wait(); } catch (Exception e) { }
  40.                 System.out.println(Thread.currentThread().getName() + "@Consumer eat..");
  41.                 res.flag = false;
  42.                 res.notify(); // 唤醒烤鸭店，烤鸭吃完啦
  43.             }
  44.     }
  45. }
  46. public class OneToOne {
  47.     public static void main(String[] args) throws InterruptedException {
  48.         PrintStream ps = logger();
  49.         Resource res = new Resource();
  50.         Producer pro = new Producer(res);
  51.         Consumer con = new Consumer(res);
  52.         Thread t1 = new Thread(pro,"生产者");
  53.         Thread t2 = new Thread(con,"消费者");
  54.         t1.start();
  55.         t2.start();
  56.         Thread.sleep(250);
  57.         ps.close();
  58.     }
  59.     public static PrintStream logger(){
  60.         PrintStream ps = null;
  61.         try {
  62.             ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("log.txt")),true);
  63.         } catch (FileNotFoundException e) {
  64.             e.printStackTrace();
  65.         }
  66.         System.setOut(ps);
  67.         return ps;
  68.     }
  69. } ///:OK~

假唤醒与自旋锁

对于上面的代码，这是面对于一个生产者和一个消费者的情形，如果是多个生产者和多个消费者的情形，那么会出现什么现象呢。假如现在没有了烤鸭，一个生产者开始生产了烤鸭，接下来在无限循环中的第二次判断使得该生产者处于了冻结状态，由于CPU的执行切换可能导致另一个生产者获得了CPU的执行权，此时烤鸭未被消费，也将处于冻结状态。直到一个消费者消费了一只烤鸭，如果监视器随机唤醒的线程恰好为一个生产者，那么很荣幸，生产者将会生成一只烤鸭，接下来监视器如果唤醒的仍然是一个生产者，此时生产者并不会判断烤鸭是否被消费而去直接生产烤鸭，这将会导致有两只烤鸭存在！以下为代码示例：

  1. import java.io.BufferedOutputStream;
  2. import java.io.FileNotFoundException;
  3. import java.io.FileOutputStream;
  4. import java.io.PrintStream;
  6. // 资源代表烤鸭
  7. class Resource{
  8.     boolean flag; // 通过标志位判断烤鸭是否做好了
  9. }
  10. // 生产者代表餐厅
  11. class Producer implements Runnable{
  12.     private Resource res;
  13.     public Producer(Resource res) {
  14.         this.res = res;
  15.     }
  16.     @Override
  17.     public void run() {
  18.         while (true)
  19.             synchronized (res) { // 临界区
  20.                 if (res.flag)
  21.                     try { res.wait(); } catch (InterruptedException e) { }
  22.                 System.out.println(Thread.currentThread().getName() + "@Producer run..");
  23.                 res.flag = true;
  24.                 res.notify(); // 唤醒消费者，烤鸭做好啦
  25.             }
  26.     }
  27. }
  28. // 消费者
  29. class Consumer implements Runnable{
  30.     private Resource res;
  31.     public Consumer(Resource res) {
  32.         this.res = res;
  33.     }
  34.     @Override
  35.     public void run() {
  36.         while (true)
  37.             synchronized (res) { // 临界区
  38.                 if (!res.flag)
  39.                     try { res.wait(); } catch (Exception e) { }
  40.                 System.out.println(Thread.currentThread().getName() + "@Consumer eat..");
  41.                 res.flag = false;
  42.                 res.notify(); // 唤醒烤鸭店，烤鸭吃完啦
  43.             }
  44.     }
  45. }
  46. public class OneToOne {
  47.     // 两个生产者与一个消费者
  48.     public static void main(String[] args) throws InterruptedException {
  49.         PrintStream ps = logger();
  50.         Resource res = new Resource();
  51.         Producer pro1 = new Producer(res);
  52.         Producer pro2 = new Producer(res);
  53.         Consumer con1 = new Consumer(res);
  54.         Thread t1 = new Thread(pro1,"生产者1");
  55.         Thread t2 = new Thread(pro2,"生产者2");
  56.         Thread t3 = new Thread(con1,"消费者");
  57.         t1.start();
  58.         t2.start();
  59.         t3.start();
  60.         Thread.sleep(250);
  61.         ps.close();
  62.     }
  64.     public static PrintStream logger(){
  65.         PrintStream ps = null;
  66.         try {
  67.             ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("log2.txt")),true);
  68.         } catch (FileNotFoundException e) {
  69.             e.printStackTrace();
  70.         }
  71.         System.setOut(ps);
  72.         return ps;
  73.     }
  74. } /* Output: // 输出顺序并不确定，以下log2.txt文件中的一部分
  75. ...
  76. 生产者2@Producer run..
  77. 消费者@Consumer eat..
  78. 生产者2@Producer run..
  79. 生产者1@Producer run..
  80. 生产者2@Producer run..
  81. 生产者1@Producer run..
  82. 生产者2@Producer run..
  83. 生产者1@Producer run..
  84. ...
  85. *///:~

假唤醒：等待线程即使没有收到正确的信号，也能够执行后续的操作。

为了防止假唤醒，保存信号的成员变量将在一个while循环里接受检查，而不是在if表达式里。这样的一个while循环叫做自旋锁。代码修改如下：

  1. // 资源代表烤鸭
  2. class Resource{
  3.     boolean flag; // 通过标志位判断烤鸭是否做好了
  4. }
  5. // 生产者代表餐厅
  6. class Producer implements Runnable{
  7.     private Resource res;
  8.     public Producer(Resource res) {
  9.         this.res = res;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         while (true)
  14.             synchronized (res) { // 临界区
  15.                 while (res.flag)
  16.                     try { res.wait(); } catch (InterruptedException e) { }
  17.                 System.out.println(Thread.currentThread().getName() + "@Producer run..");
  18.                 res.flag = true;
  19.                 res.notify(); // 随机唤醒一个冻结了的线程
  20.             }
  21.     }
  22. }
  23. // 消费者
  24. class Consumer implements Runnable{
  25.     private Resource res;
  26.     public Consumer(Resource res) {
  27.         this.res = res;
  28.     }
  29.     @Override
  30.     public void run() {
  31.         while (true)
  32.             synchronized (res) { // 临界区
  33.                 while (!res.flag)
  34.                     try { res.wait(); } catch (Exception e) { }
  35.                 System.out.println(Thread.currentThread().getName() + "@Consumer eat..");
  36.                 res.flag = false;
  37.                 res.notify();
  38.             }
  39.     }
  40. }
  41. public class OneToOne {
  42.     // 两个生产者与一个消费者
  43.     public static void main(String[] args) throws InterruptedException {
  44.         Resource res = new Resource();
  45.         Producer pro1 = new Producer(res);
  46.         Producer pro2 = new Producer(res);
  47.         Consumer con1 = new Consumer(res);
  48.         Thread t1 = new Thread(pro1,"生产者1");
  49.         Thread t2 = new Thread(pro2,"生产者2");
  50.         Thread t3 = new Thread(con1,"消费者");
  51.         t1.start();
  52.         t2.start();
  53.         t3.start();
  54.     }
  55. } /* Output: // 输出顺序并不确定，以下输出语句的一部分
  56. ...
  57. 生产者1@Producer run..
  58. 消费者@Consumer eat..
  59. 生产者2@Producer run..
  60. 消费者@Consumer eat.. // 输出停止了
  61. *///:~

为什么会输出停止？自旋锁防止了第二个生产者被唤醒后，没有接受检查而直接进行生成。`while``循环会再执行一次，促使醒来的线程回到等待状态。想想这么一种情景：这两个生产者因为生产过烤鸭而处于冻结状态，接着消费者消费了一只烤鸭后而处于冻结状态，同时唤醒了随机一个生产者线程。这个生产者在生成了一个烤鸭后，唤醒一个线程后自身处于冻结状态。如果随机唤醒了的线程为另一个生产者线程，这个生产者会因为自旋锁而处于冻结状态。到现在为止，这三个线程都处于了冻结状态，这就是为什么输出停止的原因。

死锁

就像上面代码所演示的，这种输出中止的现象我们称之为死锁，记住while判断标记+notify会导致死锁，死锁表现之一为所有的线程都处于冻结状态。notify因为唤醒的是同任务的线程而没有唤醒其他线程，如果要解决这种问题，我们可以使用notifyAll，这个方法会唤醒所有线程，可以避免死锁的发生！

  1. // 资源代表烤鸭
  2. class Resource{
  3.     boolean flag; // 通过标志位判断烤鸭是否做好了
  4. }
  5. // 生产者代表餐厅
  6. class Producer implements Runnable{
  7.     private Resource res;
  8.     public Producer(Resource res) {
  9.         this.res = res;
  10.     }
  11.     @Override
  12.     public void run() {
  13.         while (true)
  14.             synchronized (res) { // 临界区
  15.                 while (res.flag)
  16.                     try { res.wait(); } catch (InterruptedException e) { }
  17.                 System.out.println(Thread.currentThread().getName() + "@Producer run..");
  18.                 res.flag = true;
  19.                 res.notifyAll(); // 唤醒所有线程
  20.             }
  21.     }
  22. }
  23. // 消费者
  24. class Consumer implements Runnable{
  25.     private Resource res;
  26.     public Consumer(Resource res) {
  27.         this.res = res;
  28.     }
  29.     @Override
  30.     public void run() {
  31.         while (true)
  32.             synchronized (res) { // 临界区
  33.                 while (!res.flag)
  34.                     try { res.wait(); } catch (Exception e) { }
  35.                 System.out.println(Thread.currentThread().getName() + "@Consumer eat..");
  36.                 res.flag = false;
  37.                 res.notifyAll(); 
  38.             }
  39.     }
  40. }
  41. public class OneToOne {
  42.     // 两个生产者与一个消费者
  43.     public static void main(String[] args) throws InterruptedException {
  44.         Resource res = new Resource();
  45.         Producer pro1 = new Producer(res);
  46.         Producer pro2 = new Producer(res);
  47.         Consumer con1 = new Consumer(res);
  48.         Thread t1 = new Thread(pro1,"生产者1");
  49.         Thread t2 = new Thread(pro2,"生产者2");
  50.         Thread t3 = new Thread(con1,"消费者");
  51.         t1.start();
  52.         t2.start();
  53.         t3.start();
  54.     }
  55. } ///:OK~

死锁更常见的场景表现为不同任务的多线程互相循环等待去持有对方任务线程占有的锁（同步的嵌套）。举个例子，甲在独木桥的一端A，乙在独木桥的另一端B，独木桥不允许两个人并行。如果甲要去B端（任务），而乙要去A端（另一个任务），如果它们一起出发（两个不同任务的线程开启），甲和乙肯定会在独木桥相碰。此时甲走过的路程（锁）和乙走过的路程（另一把锁），甲如果想到对面，则需要乙退回去（释放锁）；同样乙若想到对面，会需要甲退回。如果互不想让的话，那么就谁也无法前进（死锁发生）。

  1. class Lock {
  2.     // 两把锁
  3.     public Object lockA = new Object(); // 甲走过的路程
  4.     public Object lockB = new Object(); // 乙走过的路程
  5. }
  6. // 甲的任务，从A端出发
  7. class RunA implements Runnable {
  8.     private Lock lock;
  9.     public RunA(Lock lock) {
  10.         this.lock = lock;
  11.     }
  12.     @Override
  13.     public void run() {
  14.         while (true)
  15.             synchronized (lock.lockA) {
  16.                 System.out.print(" 甲要去B端");
  17.                 synchronized (lock.lockB) {
  18.                     System.out.println("，于是乙退回去");
  19.                 }
  20.             }
  21.     }
  22. }
  23. // 乙的任务，从B端出发
  24. class RunB implements Runnable {
  25.     private Lock lock;
  26.     public RunB(Lock lock) {
  27.         this.lock = lock;
  28.     }
  29.     @Override
  30.     public void run() {
  31.         while (true)
  32.             synchronized (lock.lockB) {
  33.                 System.out.print(" 乙要去A端");
  34.                 synchronized (lock.lockA) {
  35.                     System.out.println("，于是甲退回去");
  36.                 }
  37.             }
  38.     }
  39. }
  40. public class DeadLock {
  41.     public static void main(String[] args) {
  42.         Lock lock  = new Lock();
  43.         new Thread(new RunA(lock)).start();
  44.         new Thread(new RunB(lock)).start();
  45.     }
  46. } /* Output: // 输出顺序并不确定，以下输出语句的一部分
  47. ...
  48.  甲要去B端，于是乙退回去
  49.  甲要去B端，于是乙退回去
  50.  甲要去B端 乙要去A端 // 死锁发生
  51. *///:~
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注