Java中线程间的通信（synchronized,wait,notify）

素颜马尾好姑娘i 2022-07-14 07:46 199阅读 0赞

1、synchronized关键字

  1.     线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作，这将会带来巨大的价值。
  3.     关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。在下面的代码中，使用了同步块和同步方法，通过使用javap工具查看生成的class文件信息来分析synchronized关键字的实现细节，示例如下。
  5. public class Synchronized {
  6.     public static void main(String[] args) {
  8.         // 对Synchronized Class 对象加锁
  9.         synchronized (Synchronized.class) {
  11.         }
  12.         // 静态同步方法，对synchronized Clas加锁
  13.         m();
  14.     }
  16.     public static synchronized void m() {
  18.     }
  19. }
  21.      在Synchronized.class同级目录执行javap -vSynchronized.class，部分相关输出如下所示：
  23. public static void main(java.lang.String[]);
  24. // 方法修饰符，表示：public staticflags: ACC_PUBLIC, ACC_STATIC
  25. Code:
  26. stack=2, locals=1, args_size=1
  27. 0: ldc #1　　// class com/murdock/books/multithread/book/Synchronized
  28. 2: dup
  29. 3: monitorenter　　// monitorenter：监视器进入，获取锁
  30. 4: monitorexit　　 // monitorexit：监视器退出，释放锁
  31. 5: invokestatic　　#16 // Method m:()V
  32. 8: return
  33. public static synchronized void m();
  34. // 方法修饰符，表示： public static synchronized
  35. flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
  36. Code:
  37. stack=0, locals=0, args_size=0
  38. 0: return
  40.     上面class信息中，对于同步块的实现使用了monitorenter和monitorexit指令，而同步方法则是依靠方法修饰符上的ACC\_SYNCHRONIZED来完成的。无论采用哪种方式，其本质是对一个对象的监视器（monitor）进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。
  42.      任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。
  44.      下图描述了对象、对象的监视器、同步队列和执行线程之间的关系。  
  45.        ![20161202160631505][]  
  48.        从图中可以看到，任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

2、等待/通知机制

  1.     一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢？
  3.     简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。
  5. while (value != desire) {
  6.      Thread.sleep(1000);
  7. } 
  8. doSomething();
  10.    上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题。
  12.            1）难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
  14.            2）难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
  16.    以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。
  18.   等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如表所示。
  20.   ![20161202162234558][]
  22.      等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

在代码清单4-11所示的例子中，创建了两个线程——WaitThread和NotifyThread，前者检查flag值是否为false，如果符合要求，进行后续操作，否则在lock上等待，后者在睡眠了一段时间后对lock进行通知，示例如下所示。

  1. public class WaitNotify {
  2.     static boolean flag = true;
  3.     static Object lock = new Object();
  5.     public static void main(String[] args) throws Exception {
  6.         Thread waitThread = new Thread(new Wait(), "WaitThread");
  7.         waitThread.start();
  8.         TimeUnit.SECONDS.sleep(1);
  9.         Thread notifyThread = new Thread(new Notify(), "NotifyThread");
  10.         notifyThread.start();
  11.     }
  13.     static class Wait implements Runnable {
  14.         public void run() {
  15.             // 加锁，拥有lock的Monitor
  16.             synchronized (lock) {
  17.                 // 当条件不满足时，继续wait，同时释放了lock的锁
  18.                 while (flag) {
  19.                     try {
  20.                         System.out.println(Thread.currentThread()
  21.                                 + " flag is true. wait@ "
  22.                                 + new SimpleDateFormat("HH:mm:ss")
  23.                                         .format(new Date()));
  24.                         lock.wait();
  25.                     } catch (InterruptedException e) {
  26.                     }
  27.                 }
  28.                 // 条件满足时，完成工作
  29.                 System.out.println(Thread.currentThread()
  30.                         + " flag is false. running@ "
  31.                         + new SimpleDateFormat("HH:mm:ss").format(new Date()));
  32.             }
  33.         }
  34.     }
  36.     static class Notify implements Runnable {
  37.         public void run() {
  38.             // 加锁，拥有lock的Monitor
  39.             synchronized (lock) {
  40.                 // 获取lock的锁，然后进行通知，通知时不会释放lock的锁，
  41.                 // 直到当前线程释放了lock后，WaitThread才能从wait方法中返回
  42.                 System.out.println(Thread.currentThread()
  43.                         + " hold lock. notify @ "
  44.                         + new SimpleDateFormat("HH:mm:ss").format(new Date()));
  45.                 lock.notifyAll();
  46.                 flag = false;
  47.                 try {
  48.                     TimeUnit.SECONDS.sleep(5);
  49.                 } catch (InterruptedException e) {
  50.                     e.printStackTrace();
  51.                 }
  52.             }
  53.             // 再次加锁
  54.             synchronized (lock) {
  55.                 System.out.println(Thread.currentThread()
  56.                         + " hold lock again. sleep@ "
  57.                         + new SimpleDateFormat("HH:mm:ss").format(new Date()));
  58.                 try {
  59.                     TimeUnit.SECONDS.sleep(5);
  60.                 } catch (InterruptedException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.         }
  65.     }
  66. }
  68.     输出如下（输出内容可能不同，主要区别在时间上）
  70. Thread[WaitThread,5,main] flag is true. wait@ 16:15:44
  71. Thread[NotifyThread,5,main] hold lock. notify @ 16:15:45
  72. Thread[NotifyThread,5,main] hold lock again. sleep@ 16:15:50
  73. Thread[WaitThread,5,main] flag is false. running@ 16:15:55
  75.   上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。
  77.      1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
  79.      2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
  81.      3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
  83.      4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
  85.      5）从wait()方法返回的前提是获得了调用对象的锁。
  87.  从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。下图描述了上述示例的过程。

20161202162545083 

  1.     在图中，WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

3、生产者/消费者模式

  1. 3.1 Consumer.java
  3. public class Consumer extends Thread {
  4.     // 每次消费的产品数量
  5.     private int num;
  7.     // 所在放置的仓库
  8.     private Storage storage;
  10.     // 构造函数，设置仓库
  11.     public Consumer(Storage storage) {
  12.         this.storage = storage;
  13.     }
  15.     // 线程run函数
  16.     public void run() {
  17.         consume(num);
  18.     }
  20.     // 调用仓库Storage的生产函数
  21.     public void consume(int num) {
  22.         storage.consume(num);
  23.     }
  25.     // get/set方法
  26.     public int getNum() {
  27.         return num;
  28.     }
  30.     public void setNum(int num) {
  31.         this.num = num;
  32.     }
  34.     public Storage getStorage() {
  35.         return storage;
  36.     }
  38.     public void setStorage(Storage storage) {
  39.         this.storage = storage;
  40.     }
  41. }
  43. 3.2 Producer.java
  45. public class Producer extends Thread {
  46.     // 每次生产的产品数量
  47.     private int num;
  49.     // 所在放置的仓库
  50.     private Storage storage;
  52.     // 构造函数，设置仓库
  53.     public Producer(Storage storage) {
  54.         this.storage = storage;
  55.     }
  57.     // 线程run函数
  58.     public void run() {
  59.         produce(num);
  60.     }
  62.     // 调用仓库Storage的生产函数
  63.     public void produce(int num) {
  64.         storage.produce(num);
  65.     }
  67.     // get/set方法
  68.     public int getNum() {
  69.         return num;
  70.     }
  72.     public void setNum(int num) {
  73.         this.num = num;
  74.     }
  76.     public Storage getStorage() {
  77.         return storage;
  78.     }
  80.     public void setStorage(Storage storage) {
  81.         this.storage = storage;
  82.     }
  83. }
  88. 3.3 Storage.java
  90. public class Storage {
  91.     // 仓库最大存储量
  92.     private final int MAX_SIZE = 100;
  94.     // 仓库存储的载体
  95.     private LinkedList<Object> list = new LinkedList<Object>();
  97.     // 生产num个产品
  98.     public void produce(int num) {
  99.         // 同步代码段
  100.         synchronized (list) {
  101.             // 如果仓库剩余容量不足
  102.             while (list.size() + num > MAX_SIZE) {
  103.                 System.out.println("【要生产的产品数量】:" + num + "\t【库可以存放存量】:"
  104.                         + list.size() + "\t暂时不能执行生产任务!");
  105.                 try {
  106.                     // 由于条件不满足，生产阻塞
  107.                     list.wait();
  108.                 } catch (InterruptedException e) {
  109.                     e.printStackTrace();
  110.                 }
  111.             }
  113.             // 生产条件满足情况下，生产num个产品
  114.             for (int i = 1; i <= num; ++i) {
  115.                 list.add(new Object());
  116.             }
  118.             System.out.println("【已经生产产品数】:" + num + "\t【现仓储量为】:" + list.size());
  119.             // 通知消费者来消费
  120.             list.notifyAll();
  121.         }
  122.     }
  124.     // 消费num个产品
  125.     public void consume(int num) {
  126.         // 同步代码段
  127.         synchronized (list) {
  128.             // 如果仓库存储量不足
  129.             while (list.size() < num) {
  130.                 System.out.println("【要消费的产品数量】:" + num + "\t【库存量】:"
  131.                         + list.size() + "\t暂时不能执行生产任务!");
  132.                 try {
  133.                     // 由于条件不满足，消费阻塞
  134.                     list.wait();
  135.                 } catch (InterruptedException e) {
  136.                     e.printStackTrace();
  137.                 }
  138.             }
  140.             // 消费条件满足情况下，消费num个产品
  141.             for (int i = 1; i <= num; ++i) {
  142.                 list.remove();
  143.             }
  145.             System.out.println("【已经消费产品数】:" + num + "\t【现仓储量为】:" + list.size());
  146.             // 通知生产者生产
  147.             list.notifyAll();
  148.         }
  149.     }
  151.     // get/set方法
  152.     public LinkedList<Object> getList() {
  153.         return list;
  154.     }
  156.     public void setList(LinkedList<Object> list) {
  157.         this.list = list;
  158.     }
  160.     public int getMAX_SIZE() {
  161.         return MAX_SIZE;
  162.     }
  163. }
  165. 3.4 Test.java
  167. public class Test {
  168.     public static void main(String[] args) {
  169.         // 仓库对象
  170.         Storage storage = new Storage();
  172.         // 生产者对象
  173.         Producer p1 = new Producer(storage);
  174.         Producer p2 = new Producer(storage);
  175.         Producer p3 = new Producer(storage);
  176.         Producer p4 = new Producer(storage);
  177.         Producer p5 = new Producer(storage);
  178.         Producer p6 = new Producer(storage);
  179.         Producer p7 = new Producer(storage);
  181.         // 消费者对象
  182.         Consumer c1 = new Consumer(storage);
  183.         Consumer c2 = new Consumer(storage);
  184.         Consumer c3 = new Consumer(storage);
  186.         // 设置生产者产品生产数量
  187.         p1.setNum(10);
  188.         p2.setNum(10);
  189.         p3.setNum(10);
  190.         p4.setNum(10);
  191.         p5.setNum(10);
  192.         p6.setNum(10);
  193.         p7.setNum(80);
  195.         // 设置消费者产品消费数量
  196.         c1.setNum(50);
  197.         c2.setNum(20);
  198.         c3.setNum(30);
  200.         // 线程开始执行
  201.         c1.start();
  202.         c2.start();
  203.         c3.start();
  204.         p1.start();
  205.         p2.start();
  206.         p3.start();
  207.         p4.start();
  208.         p5.start();
  209.         p6.start();
  210.         p7.start();
  211.     }
  212. }

4、参考的内容

  1. Java并发编程的艺术
  2. http://blog.csdn.net/monkey_d_meng/article/details/6251879

发表评论

表情：
评论列表 （有 0 条评论，199人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java线程间通信

    Java是通过Object 类的wait（） notify（） notifyAll（） 这几个方法实现线程间通信的。 wait（）：通知该线程进入睡眠状态，直到其他线程进入并

    - 日理万妓- 日理万妓/ 0 赞/ 365 阅读

    相关 Java线程间通信

    上述例题无条件的阻塞了其他线程异步访问某个方法。Java对象中隐式管程的应用是很强大的，但是你可以通过进程间通信达到更微妙的境界。这在Java中是尤为简单的。 像前面

    古城微笑少年丶古城微笑少年丶/ 0 赞/ 387 阅读