Java并发包——线程通信

Java并发包——线程通信

摘要：本文主要学习了Java并发包里有关线程通信的一些知识。

部分内容来自以下博客：

https://www.cnblogs.com/skywang12345/p/3496716.html

线程通信方式

对于线程之间的通信方式，我们之前使用Object.wait()和Object.notify()，通过与synchronized关键字进行同步，两者配合使用，可以实现线程之间的通信。

后来在JUC并发包里发现可以使用Lock取代synchronized关键字实现线程之间的同步，并且使用Lock的方式有比synchronized方式更加强大的功能，为了同Lock配合，实现线程之间的通信，就要用到Condition。

Condition的作用是对锁进行更精确的控制。Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。不同的是，Object中的wait()、notify()、notifyAll()方法是和“同步锁”（synchronized关键字）捆绑使用的，而Condition是需要与“独享锁/共享锁”捆绑使用的。

使用Condition的优势

能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。

能够在多个线程之间进行通信。Object的wait()、notify()、notifyAll()方法只能实现两个线程之间的通信，而Lock对象能通过newCondition()方法创建出无数的“条件”，通过这些条件，我们就能够成功地实现多线程之间的数据通信，对它们进行控制。

Condition

Condition是java.util.concurrent.locks包下的一个接口，提供了用来进行线程通信的方法。

 public interface Condition {
     // 使当前线程加入等待队列中并释放当锁，被通知、被中断时唤醒。
     void await() throws InterruptedException;

     // 同await()类似，只是该方法对中断不敏感，只有被通知时才被唤醒。
     void awaitUninterruptibly();

     // 同await()类似，如果在指定时间之内没有被通知或者被中断，该方法会返回false。
     boolean await(long time, TimeUnit unit) throws InterruptedException;

     // 当前线程进入等待状态，被通知、中断或者超时之后被唤醒。返回值就是表示剩余的时间，超时返回值是0或者负数。
     long awaitNanos(long nanosTimeout) throws InterruptedException;

     // 同awaitNanos(long nanosTimeout)类似，只是参数变成了指定日期。
     boolean awaitUntil(Date deadline) throws InterruptedException;

     // 唤醒一个在等待队列中的线程。
     void signal();

     // 唤醒所有在等待队列中的线程。
     void signalAll();
 }

获取Lock上的特定Condition

Condition实例实质上被绑定到一个锁上。一个锁内部可以有多个Condition，即有多路等待和通知。要为特定Lock实例获得Condition实例，请使用Lock的newCondition()方法。

newCondition()返回用来与当前Lock实例一起使用的Condition实例。

类似于Object.wait()和Object.notify()的功能，Object.wait()与Object.notify()需要结合synchronized使用。Condition需要结合ReentrantLock使用。

使用Condition实现线程通信

使用synchronized和Object类的方法

使用synchronized和Object类的方法实现两个线程交替打印，代码如下：

 public class Demo {
     public static void main(String[] args) {
         DemoThread demoThread = new DemoThread();
         Thread a = new Thread(demoThread, "线程A");
         Thread b = new Thread(demoThread, "线程B");
         a.start();
         b.start();
     }
 }

 class DemoThread implements Runnable {
     private Integer num = 1;

     @Override
     public void run() {
         synchronized (DemoThread.class) {
             while (num <= 10) {
                 DemoThread.class.notify();
                 System.out.println(Thread.currentThread().getName() + " >>> " + num++);
                 if (num <= 10) {
                     try {
                         DemoThread.class.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     }
 }

运行结果如下：

 线程A >>> 1
 线程B >>> 2
 线程A >>> 3
 线程B >>> 4
 线程A >>> 5
 线程B >>> 6
 线程A >>> 7
 线程B >>> 8
 线程A >>> 9
 线程B >>> 10

使用Lock和Condition类的方法

使用Lock和Condition类的方法实现两个线程交替打印，代码如下：

 public class Demo {
     public static void main(String[] args) {
         DemoThread demoThread = new DemoThread();
         Thread a = new Thread(demoThread, "线程A");
         Thread b = new Thread(demoThread, "线程B");
         a.start();
         b.start();
     }
 }

 class DemoThread implements Runnable {
     private Integer num = 1;
     Lock lock = new ReentrantLock();
     Condition condition = lock.newCondition();

     @Override
     public void run() {
         lock.lock();
         try {
             while (num <= 10) {
                 condition.signal();
                 System.out.println(Thread.currentThread().getName() + " >>> " + num++);
                 if (num <= 10) {
                     condition.await();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 }

运行结果如下：

 线程A >>> 1
 线程B >>> 2
 线程A >>> 3
 线程B >>> 4
 线程A >>> 5
 线程B >>> 6
 线程A >>> 7
 线程B >>> 8
 线程A >>> 9
 线程B >>> 10

使用Lock和Condition类的方法实现三个线程按顺序循环打印

使用Lock和Condition类的方法实现三个线程按顺序打印，需要唤醒指定的线程，代码如下：

 public class Demo {
     public static void main(String[] args) {
         DemoThread demoThread = new DemoThread();
         Thread a = new Thread(() -> demoThread.run1(), "线程1");
         Thread b = new Thread(() -> demoThread.run2(), "线程2");
         Thread c = new Thread(() -> demoThread.run3(), "线程3");
         a.start();
         b.start();
         c.start();
     }
 }

 class DemoThread {
     static private Integer num = 0;
     static Lock lock = new ReentrantLock();
     Condition c1 = lock.newCondition();
     Condition c2 = lock.newCondition();
     Condition c3 = lock.newCondition();

     public void run1() {
         try {
             Thread.sleep(10);
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         }
         lock.lock();
         try {
             while (num < 10) {
                 for (int i = 0; i < 1 && num < 10; i++) {
                     System.out.println(Thread.currentThread().getName() + " >>> " + num);
                 }
                 num++;
                 c2.signal();
                 c1.await();
                 if (num >= 9) {
                     c3.signal();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void run2() {
         try {
             Thread.sleep(20);
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         }
         lock.lock();
         try {
             while (num < 10) {
                 for (int i = 0; i < 2 && num < 10; i++) {
                     System.out.println(Thread.currentThread().getName() + " >>> " + num);
                 }
                 num++;
                 c3.signal();
                 c2.await();
                 if (num >= 9) {
                     c1.signal();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void run3() {
         try {
             Thread.sleep(30);
         } catch (InterruptedException e1) {
             e1.printStackTrace();
         }
         lock.lock();
         try {
             while (num < 10) {
                 for (int i = 0; i < 3 && num < 10; i++) {
                     System.out.println(Thread.currentThread().getName() + " >>> " + num);
                 }
                 num++;
                 c1.signal();
                 c3.await();
                 if (num >= 9) {
                     c2.signal();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }
 }

运行结果如下：

 线程1 >>> 0
 线程2 >>> 1
 线程2 >>> 1
 线程3 >>> 2
 线程3 >>> 2
 线程3 >>> 2
 线程1 >>> 3
 线程2 >>> 4
 线程2 >>> 4
 线程3 >>> 5
 线程3 >>> 5
 线程3 >>> 5
 线程1 >>> 6
 线程2 >>> 7
 线程2 >>> 7
 线程3 >>> 8
 线程3 >>> 8
 线程3 >>> 8
 线程1 >>> 9

Condition中的await()、signal()、signalAll()与Object中的wait()、notify()、notifyAll()区别

使用方式不同

Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法，Condition中的signalAll()相当于Object的notifyAll()方法。

不同的是，Object中的这些方法是和同步锁捆绑使用的，而Condition是需要与互斥锁/共享锁捆绑使用的。

功能更加强大

Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。

例如，假如多线程读/写同一个缓冲区：当向缓冲区中写入数据之后，唤醒“读线程”。当从缓冲区读出数据之后，唤醒“写线程”。当缓冲区满的时候，“写线程”需要等待。当缓冲区为空时，“读线程”需要等待。

如果采用Object类中的wait()、notify()、notifyAll()实现该缓冲区，当向缓冲区写入数据之后需要唤醒“读线程”时，不可能通过notify()或notifyAll()明确的指定唤醒"读线程"，而只能通过notifyAll唤醒所有线程，但是notifyAll无法区分唤醒的线程是读线程，还是写线程。

但是，通过Condition，就能明确的指定唤醒读线程。