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，就能明确的指定唤醒读线程。