java多线程之生产者消费者模式-线程同步问题，java线程生死锁问题。生产者与消费者问题是线程模型中的经典问题：生产者与消费者在同一时间段内共用同一个存储空间，如下图，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：
java生产者消费者模式-线程同步问题
存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。
JAVA解决线程模型的三种方式
1、wait和notify模型
package com.ch.egg;
import java.util.ArrayList;
import java.util.List;
public class ThreadEgg {
private List<Object> eggs = new ArrayList<Object>();
/**
* 若不拥有对象的锁标记(synchronized)，而试图用wait/notify协调共享对象资源，
* 应用程序将抛出IllegalMonitorStateException。
*
* @param i
* @return
*/
public synchronized Object getEggs(int i) {
//若盘里鸡蛋为0，则wait()阻塞进入队列，等待生产者(放鸡蛋)线程唤醒
if(eggs.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Object egg = eggs.get(0);
eggs.clear();
notify();
System.out.println(“拿到 鸡蛋”+i);
return egg;
}
public synchronized void pugEgg(Object egg,int i) {
//若盘里鸡蛋为1，则wait()阻塞进入队列，等待消费者(取鸡蛋)线程唤醒
if(eggs.size() > 0) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
eggs.add(egg);
notify();
System.out.println(“放入 鸡蛋”+i);
}
static class AddThread extends Thread {
private ThreadEgg threadEgg;
private Object egg ;
public AddThread(ThreadEgg threadEgg) {
this.threadEgg = threadEgg;
}
public void run() {
for(int i = 0;i<5;i++){
threadEgg.pugEgg(egg,i);
}
}
}
static class GetThread extends Thread{
private ThreadEgg threadEgg;
public GetThread(ThreadEgg threadEgg) {
this.threadEgg = threadEgg;
}
public void run(){
for(int i=0;i<5;i++){
threadEgg.getEggs(i);
}
}
}
public static void main(String[] args) {
try {
ThreadEgg threadEgg = new ThreadEgg();
AddThread aTh = new AddThread(threadEgg);
GetThread gTh = new GetThread(threadEgg);
aTh.start();
gTh.start();
aTh.join();
gTh.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(“over……”);
}
}
2、await()和signal()，即线程锁的方式
package com.ch.egg;
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* ReentrantLock 是一个可重入的互斥锁 Lock，
* 它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大
*
* Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，
* 以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。
* 其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
*
* @author ch
*
*/
public class ThreadEggLock {
private LinkedList<Object> eggs = new LinkedList<Object>();
private int MAX = 1;
private final Lock lock = new ReentrantLock();
private final Condition full = lock.newCondition();
private final Condition empty = lock.newCondition();
private int count = 0;
public void start() {
new Producer().start();
new Consumer().start();
}
public static void main(String[] args) throws Exception {
ThreadEggLock s2 = new ThreadEggLock();
s2.start();
}
class Producer extends Thread {
public void run() {
while (count < 5) {
lock.lock();
try {
while (eggs.size() == MAX) { //盘子里满了
System.out.println(“——警告：盘子里满了!”);
full.await();
}
Object egg = new Object();
if (eggs.add(egg)) {
System.out.println(“放入 鸡蛋” + count);
empty.signal();
}
} catch (InterruptedException ie) {
System.out.println(“producer is interrupted!”);
} finally {
lock.unlock();
}
}
}
}
class Consumer extends Thread {
public void run() {
while (count <= 5) {
lock.lock();
try {
while (eggs.size() == 0) { //盘子是空的
System.out.println(“——警告：现在盘子是空的”);
empty.await();
}
eggs.removeLast();
System.out.println(“拿走 鸡蛋” + count);
count++;
full.signal();
} catch (InterruptedException ie) {
System.out.println(“consumer is interrupted!”);
} finally {
lock.unlock();
}
}
}
}
}
3、阻塞队列的方式
package com.ch.egg;
import java.util.concurrent.LinkedBlockingQueue;
public class ThreadEggBlock {
// 建立一个阻塞队列
/**
* 一个基于已链接节点的、范围任意的 blocking queue。
* 此队列按 FIFO（先进先出）排序元素。
* 队列的头部 是在队列中时间最长的元素;队列的尾部 是在队列中时间最短的元素。
*
* 新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素。
* 链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。
*/
private LinkedBlockingQueue<Object> queue_eggs =
new LinkedBlockingQueue<Object>(1);
private int count = 1;
public void start() throws InterruptedException {
Producer producer = new Producer();
Consumer consumer = new Consumer();
producer.start();
consumer.start();
}
public static void main(String[] args) throws Exception {
ThreadEggBlock s3 = new ThreadEggBlock();
s3.start();
}
class Producer extends Thread {
public void run() {
while (count < 15) {
try {
Egg egg = new Egg(String.valueOf(count));
queue_eggs.put(egg);
System.out.println(“放入 鸡蛋” + egg.getName());
count++;
} catch (InterruptedException e) {
System.out.println(“producer is interrupted!”);
}
}
}
}
class Consumer extends Thread {
public void run() {
while (count <= 15) {
try {
// 取出一个对象
Egg egg = (Egg) queue_eggs.take();
System.out.println(“取出 鸡蛋” + egg.getName());
} catch (InterruptedException e) {
System.out.println(“producer is interrupted!”);
}
}
}
}
class Egg {
private String name;
public Egg(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
总结：
1、处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，是任何语言多线程必学的例子。
2、三种方式实现同步的原理一致，都是对独占空间加锁，阻塞和唤醒线程；第一种方式比较传统，第二种方式最灵活，第三种方式最简单，只需存储和取用，线程同步的操作交由LinkedBlockingQueue全权处理。
线程同步小结