本篇文章基于synchronized和ReentrantLock来讲解如何进行线程间通信，关于上述两种锁的内容，可以看这篇文章。本篇文章关于线程间通信的讲解将围绕生产者/消费者模式以实例的形式全方位展示线程间通信的方式。（篇幅较长，主要是代码，逻辑很简单，一看就懂，不要有压力）
一、线程间通信的两种方式
1.wait()/notify()
Object类中相关的方法有notify方法和wait方法。因为wait和notify方法定义在Object类中，因此会被所有的类所继承。这些方法都是final的，即它们都是不能被重写的，不能通过子类覆写去改变它们的行为。
①wait()方法：让当前线程进入等待，并释放锁。
②wait(long)方法：让当前线程进入等待，并释放锁，不过等待时间为long，超过这个时间没有对当前线程进行唤醒，将自动唤醒。
③notify()方法：让当前线程通知那些处于等待状态的线程，当前线程执行完毕后释放锁，并从其他线程中唤醒其中一个继续执行。
④notifyAll()方法：让当前线程通知那些处于等待状态的线程，当前线程执行完毕后释放锁，将唤醒所有等待状态的线程。
wait()方法使用注意事项
①当前的线程必须拥有当前对象的monitor，也即lock，就是锁，才能调用wait()方法，否则将抛出异常java.lang.IllegalMonitorStateException。
②线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll()方法），这样它才能重新获得锁的拥有权和恢复执行。
③要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。
wait()与sleep()比较
当线程调用了wait()方法时，它会释放掉对象的锁。
Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。
notify()方法使用注意事项
①如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关。（线程等待一个对象的锁是由于调用了wait()方法）。
②被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁，当前线程会在方法执行完毕后释放锁。
wait()/notify()协作的两个注意事项
①通知过早
如果通知过早，则会打乱程序的运行逻辑。
public class MyRun {
private String lock = new String("");
public Runnable runnableA = new Runnable() {
@Override
public void run() {
try {
synchronized (lock) {
System.out.println("begin wait");
lock.wait();
System.out.println("end wait");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
public Runnable runnableB = new Runnable() {
@Override
public void run() {
synchronized (lock) {
System.out.println("begin notify");
lock.notify();
System.out.println("end notify");
}
}
};
}
两个方法，分别执行wait()/notify()方法。
public static void main(String[] args) throws InterruptedException {
MyRun run = new MyRun();
Thread bThread = new Thread(run.runnableB);
bThread.start();
Thread.sleep(100);
Thread aThread = new Thread(run.runnableA);
aThread.start();
}
如果notify()方法先执行，将导致wait()方法释放锁进入等待状态后，永远无法被唤醒，影响程序逻辑。应避免这种情况。
②等待wait的条件发生变化
在使用wait/notify模式时，还需要注意另外一种情况，也就是wait等待条件发生了变化，也容易造成程序逻辑的混乱。
Add类，执行加法操作，然后通知Subtract类
public class Add {
private String lock;
public Add(String lock) {
super();
this.lock = lock;
}
public void add(){
synchronized (lock) {
ValueObject.list.add("anyThing");
lock.notifyAll();
}
}
}
Subtract类，执行减法操作，执行完后进入等待状态，等待Add类唤醒notify
public class Subtract {
private String lock;
public Subtract(String lock) {
super();
this.lock = lock;
}
public void subtract(){
try {
synchronized (lock) {
if(ValueObject.list.size()==0){
System.out.println("wait begin ThreadName="+Thread.currentThread().getName());
lock.wait();
System.out.println("wait end ThreadName="+Thread.currentThread().getName());
}
ValueObject.list.remove(0);
System.out.println("list size ="+ValueObject.list.size());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
**线程ThreadAdd **
public class ThreadAdd extends Thread{
private Add pAdd;
public ThreadAdd(Add pAdd) {
super();
this.pAdd = pAdd;
}
@Override
public void run() {
pAdd.add();
}
}
**线程ThreadSubtract **
public class ThreadSubtract extends Thread{
private Subtract rSubtract;
public ThreadSubtract(Subtract rSubtract) {
super();
this.rSubtract = rSubtract;
}
@Override
public void run() {
rSubtract.subtract();
}
}
先开启两个ThreadSubtract线程，由于list中没有元素，进入等待状态。再开启一个ThreadAdd线程，向list中增加一个元素，然后唤醒两个ThreadSubtract线程
public static void main(String[] args) throws InterruptedException {
String lock = new String("");
Add add = new Add(lock);
Subtract subtract = new Subtract(lock);
ThreadSubtract subtractThread1 = new ThreadSubtract(subtract);
subtractThread1.setName("subtractThread1");
subtractThread1.start();
ThreadSubtract subtractThread2 = new ThreadSubtract(subtract);
subtractThread2.setName("subtractThread2");
subtractThread2.start();
Thread.sleep(1000);
ThreadAdd addThread = new ThreadAdd(add);
addThread.setName("addThread");
addThread.start();
}
输出结果
wait begin ThreadName=subtractThread1
wait begin ThreadName=subtractThread2
wait end ThreadName=subtractThread2
Exception in thread “subtractThread1” list size =0
wait end ThreadName=subtractThread1
java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
at java.util.ArrayList.rangeCheck(Unknown Source)
at java.util.ArrayList.remove(Unknown Source)
at com.lvr.communication.Subtract.subtract(Subtract.java:18)
at com.lvr.communication.ThreadSubtract.run(ThreadSubtract.java:12)
当第二个ThreadSubtract线程执行减法操作时，抛出下标越界异常。
原因分析：一开始两个ThreadSubtract线程等待状态，当ThreadAdd线程添加一个元素并唤醒所有线程后，第一个ThreadSubtract线程接着原来的执行到的地点开始继续执行，删除一个元素并输出集合大小。同样，第二个ThreadSubtract线程也如此，可是此时集合中已经没有元素了，所以抛出异常。
解决办法：从等待状态被唤醒后，重新判断条件，看看是否扔需要进入等待状态，不需要进入再进行下一步操作。即把if()判断，改成while()。
public void subtract(){
try {
synchronized (lock) {
while(ValueObject.list.size()==0){
System.out.println("wait begin ThreadName="+Thread.currentThread().getName());
lock.wait();
System.out.println("wait end ThreadName="+Thread.currentThread().getName());
}
ValueObject.list.remove(0);
System.out.println("list size ="+ValueObject.list.size());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
这是线程间协作中经常出现的一种情况，需要避免。
2.Condition实现等待/通知
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式，类似ReentrantLock也可以实现同样的功能，但需要借助于Condition对象。
关于Condition实现等待/通知就不详细介绍了，可以完全类比wait()/notify()，基本使用和注意事项完全一致。
就只简单介绍下类比情况：
condition.await()————>lock.wait()
condition.await(long time, TimeUnit unit)————>lock.wait(long timeout)
condition.signal()————>lock.notify()
condition.signaAll()————>lock.notifyAll()
特殊之处：synchronized相当于整个ReentrantLock对象只有一个单一的Condition对象情况。而一个ReentrantLock却可以拥有多个Condition对象，来实现通知部分线程。
具体实现方式：
假设有两个Condition对象：ConditionA和ConditionB。那么由ConditionA.await()方法进入等待状态的线程，由ConditionA.signalAll()通知唤醒；由ConditionB.await()方法进入等待状态的线程，由ConditionB.signalAll()通知唤醒。篇幅有限，代码示例就不写了。
二、生产者/消费者模式实现
1.一生产与一消费
下面情形是一个生产者，一个消费者的模式。假设场景：一个String对象，其中生产者为其设置值，消费者拿走其中的值，不断的循环往复，实现生产者/消费者的情形。
wait()/notify()实现
生产者
public class Product {
private String lock;
public Product(String lock) {
super();
this.lock = lock;
}
public void setValue(){
try {
synchronized (lock) {
if(!StringObject.value.equals("")){
//有值，不生产
lock.wait();
}
String value = System.currentTimeMillis()+""+System.nanoTime();
System.out.println("set的值是："+value);
StringObject.value = value;
lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
消费者
public class Consumer {
private String lock;
public Consumer(String lock) {
super();
this.lock = lock;
}
public void getValue(){
try {
synchronized (lock) {
if(StringObject.value.equals("")){
//没值，不进行消费
lock.wait();
}
System.out.println("get的值是："+StringObject.value);
StringObject.value = "";
lock.notify();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
生产者线程
public class ThreadProduct extends Thread{
private Product product;
public ThreadProduct(Product product) {
super();
this.product = product;
}
@Override
public void run() {
//死循环，不断的生产
while(true){
product.setValue();
}
}
}
消费者线程
public class ThreadConsumer extends Thread{
private Consumer consumer;
public ThreadConsumer(Consumer consumer) {
super();
this.consumer = consumer;
}
@Override
public void run() {
//死循环，不断的消费
while(true){
consumer.getValue();
}
}
}
开启生产者/消费者模式
public class Test {
public static void main(String[] args) throws InterruptedException {
String lock = new String("");
Product product = new Product(lock);
Consumer consumer = new Consumer(lock);
ThreadProduct pThread = new ThreadProduct(product);
ThreadConsumer cThread = new ThreadConsumer(consumer);
pThread.start();
cThread.start();
}
}
输出结果：
set的值是：148827033184127168687409691
get的值是：148827033184127168687409691
set的值是：148827033184127168687449887
get的值是：148827033184127168687449887
set的值是：148827033184127168687475117
get的值是：148827033184127168687475117
Condition方式实现类似，篇幅有限不全部贴出来。
2.多生产与多消费
特殊情况：按照上述一生产与一消费的情况，通过创建多个生产者和消费者线程，实现多生产与多消费的情况，将会出现“假死”。
具体原因：多个生产者和消费者线程。当全部运行后，生产者线程生产数据后，可能唤醒的同类即生产者线程。此时可能会出现如下情况：所有生产者线程进入等待状态，然后消费者线程消费完数据后，再次唤醒的还是消费者线程，直至所有消费者线程都进入等待状态，此时将进入“假死”。
解决方法：将notify()或signal()方法改为notifyAll()或signalAll()方法，这样就不怕因为唤醒同类而进入“假死”状态了。
Condition方式实现
生产者
public class Product {
private ReentrantLock lock;
private Condition condition;
public Product(ReentrantLock lock, Condition condition) {
super();
this.lock = lock;
this.condition = condition;
}
public void setValue() {
try {
lock.lock();
while (!StringObject.value.equals("")) {
// 有值，不生产
condition.await();
}
String value = System.currentTimeMillis() + "" + System.nanoTime();
System.out.println("set的值是：" + value);
StringObject.value = value;
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
消费者
public class Consumer {
private ReentrantLock lock;
private Condition condition;
public Consumer(ReentrantLock lock,Condition condition) {
super();
this.lock = lock;
this.condition = condition;
}
public void getValue(){
try {
lock.lock();
while(StringObject.value.equals("")){
//没值，不进行消费
condition.await();
}
System.out.println("get的值是："+StringObject.value);
StringObject.value = "";
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
生产者线程和消费者线程与一生产一消费的模式相同。
开启多生产/多消费模式
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Condition newCondition = lock.newCondition();
Product product = new Product(lock,newCondition);
Consumer consumer = new Consumer(lock,newCondition);
for(int i=0;i<3;i++){
ThreadProduct pThread = new ThreadProduct(product);
ThreadConsumer cThread = new ThreadConsumer(consumer);
pThread.start();
cThread.start();
}
}
输出结果:
set的值是：148827212374628960540784817
get的值是：148827212374628960540784817
set的值是：148827212374628960540810047
get的值是：148827212374628960540810047
可见交替地进行get/set实现多生产/多消费模式。
注意：相比一生产一消费的模式，改动了两处。①signal()–>signalAll()避免进入“假死”状态。②if()判断–>while()循环，重新判断条件，避免逻辑混乱。
以上就是Java线程间通信的相关知识，以生产者/消费者模式为例，讲解线程间通信的使用以及注意事项。
