Java多线程之通信
在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步。通信是指线程之间以何种机制来交换信息。在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。
java内存模型
线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。
从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：
- 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
- 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。
另一种消息传递的方式
生产者、消费者模式
- 生产者：没有生产之前通知消费者等待，生产产品结束之后，马上通知消费者消费
- 消费者：没有消费之前通知生产者等待，消费产品结束之后，通知生产者继续生产产品以供消费
其中使用了缓冲区，需要考虑下面两点
- 从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。
- 生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。
两种发放实现生产者、消费者模式
看看下面例子：
生产者： 往一个公共的盒子里面放苹果
消费者：从公共的盒子里面取苹果
盒子：盒子的容量不能超过5
方法一：wait() 和 notify() 通信方法实现
public class PublicBox {
private int apple = 0;
public synchronized void increace() {
while (apple ==5) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple++;
System. out .println("生成苹果成功！" );
notify();
}
public synchronized void decreace() {
while (apple ==0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple--;
System. out.println( "消费苹果成功！" );
notify();
}
public static void main(String []args)
{
PublicBox box= new PublicBox();
Consumer con= new Consumer(box);
Producer pro= new Producer(box);
Thread t1= new Thread(con);
Thread t2= new Thread(pro);
t1.start();
t2.start();
}
}
多个生产者和多个消费者
生产者代码（定义十次）：
public class Producer implements Runnable {
private PublicBox box;
public Producer(PublicBox box) {
this .box = box;
}
@Override
public void run() {
for( int i=0;i<10;i++)
{
try {
System. out .println("pro i:" +i);
Thread. sleep(30);
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
box.increace();
}
}
}
消费者代码（同样十次）：
public class Consumer implements Runnable {
private PublicBox box;
public Consumer(PublicBox box) {
this .box = box;
}
@Override
public void run() {
for( int i=0;i<10;i++)
{
try {
System. out .println("Con: i " +i);
Thread. sleep(3000); // 这里设置跟上面30不同是为了 盒子中的苹果能够增加，不会生产一个马上被消费
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
box.decreace();
}
}
}
结果
pro i:0
Con: i 0
生成苹果成功！
pro i:1
生成苹果成功！
pro i:2
生成苹果成功！
pro i:3
生成苹果成功！
pro i:4
生成苹果成功！
pro i:5
消费苹果成功！
Con: i 1
生成苹果成功！
pro i:6
消费苹果成功！
Con: i 2
生成苹果成功！
pro i:7
消费苹果成功！
生成苹果成功！
pro i:8
Con: i 3
消费苹果成功！
生成苹果成功！
pro i:9
Con: i 4
消费苹果成功！
生成苹果成功！
Con: i 5
消费苹果成功！
Con: i 6
消费苹果成功！
Con: i 7
消费苹果成功！
Con: i 8
消费苹果成功！
Con: i 9
消费苹果成功！
方法二：阻塞队列实现生产者消费者模式
阻塞队列实现生产者消费者模式超级简单，它提供开箱即用支持阻塞的方法put()和take()，开发者不需要写困惑的wait-nofity代码去实现通信。BlockingQueue 一个接口，Java5提供了不同的现实，如ArrayBlockingQueue和LinkedBlockingQueue，两者都是先进先出（FIFO）顺序。而ArrayLinkedQueue是自然有界的，LinkedBlockingQueue可选的边界。下面这是一个完整的生产者消费者代码例子，对比传统的wait、nofity代码，它更易于理解。
盒子代码
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class PublicBoxQueue {
public static void main(String []args)
{
BlockingQueue publicBoxQueue= new LinkedBlockingQueue(5); //定义了一个大小为5的盒子
Thread pro= new Thread(new ProducerQueue(publicBoxQueue));
Thread con= new Thread(new ConsumerQueue(publicBoxQueue));
pro.start();
con.start();
}
}
生产者
package dsd;
import java.util.concurrent.BlockingQueue;
public class ProducerQueue implements Runnable {
private final BlockingQueue proQueue;
public ProducerQueue(BlockingQueue proQueue)
{
this .proQueue =proQueue;
}
@Override
public void run() {
// TODO Auto-generated method stub
for (int i=0;i<10;i++)
{
try {
System. out .println("生产者生产的苹果编号为 : " +i); //放入十个苹果编号 为1到10
proQueue .put(i);
/*Thread.sleep(3000);*/
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
}
消费者
package dsd;
import java.util.concurrent.BlockingQueue;
public class ConsumerQueue implements Runnable {
private final BlockingQueue conQueue;
public ConsumerQueue(BlockingQueue conQueue)
{
this .conQueue =conQueue;
}
@Override
public void run() {
// TODO Auto-generated method stub
for (int i=0;i<10;i++)
{
try {
System. out .println("消费者消费的苹果编号为 ：" +conQueue .take());
Thread. sleep(3000); //在这里sleep是为了看的更加清楚些
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
}
结果
生产者生产的苹果编号为 : 0
生产者生产的苹果编号为 : 1
消费者消费的苹果编号为 ：0
生产者生产的苹果编号为 : 2
生产者生产的苹果编号为 : 3
生产者生产的苹果编号为 : 4
生产者生产的苹果编号为 : 5
生产者生产的苹果编号为 : 6
生产者生产的苹果编号为 : 7
消费者消费的苹果编号为 ：1
消费者消费的苹果编号为 ：2
生产者生产的苹果编号为 : 8
消费者消费的苹果编号为 ：3
生产者生产的苹果编号为 : 9
消费者消费的苹果编号为 ：4
消费者消费的苹果编号为 ：5
消费者消费的苹果编号为 ：6
消费者消费的苹果编号为 ：7
消费者消费的苹果编号为 ：8
消费者消费的苹果编号为 ：9
生产者消费者模式优点
- 解耦：分开生产者和消费者的依赖，耦合度低。
- 支持并发：生产者和消费者是两个独立的并发体，他们通过缓冲区作为桥梁，生产者只需要往缓冲区里丢数据，就可以生产下一个数据，消费者只需要在缓冲区中取数据，这样两个并发体都不会因为出来速度而引起阻塞。
- 支持忙闲不均：如果生产者时快时慢，缓冲区的好处就好大，当生产者速度很快，任务就会在缓冲区缓存起来，让消费者依次去执行；当生产者速度比较慢，消费者可以从缓冲区中取任务，消费者不需要等到生产了任务才有工作，除非缓冲区为空。
应用场景
- 订单系统
- 一些需要缓存的任务系统