之前学习多线程问题遇到的最大的难度就是，非常多。生产者消费者模式是比較经典的多线程问题，看似 不难。但实际上有非常多地方值得注意的。
首先是几个问题
问题1 一共同拥有哪些对象？
生产者与消费者是肯定有的，生产者与消费者之间另一个缓冲区对象。用以保存生产与消费的目标，另一个对象就是主线程对象，用来执行多个线程的。
追问：为什么要有一个缓冲区对象？
答：为了实现生产者与消费者解耦，互补依赖或者关联。
追问：每一个对象都包括哪些变量与方法？
答：生产者包括缓冲区对象并在run()方法里面运行生产调度命令；消费者含缓冲区对象并在run()方法里面运行消费调度命令；缓冲区则保存产品的数组/Stack/Queue以及生产与消费的详细指令。主线程对象则用来实现生产者与消费者线程创建与运行的。
问题2 哪些方法须要同步？
缓冲区对象的生产与消费必须实现同步。
我在进行研究的时候，会出现例如以下错误的代码：
/**
* 项目名称：
* 文件说明：
* 主要特点：生产者消费者模式
* 版本：1.0
* 制作人：lcx
* 创建时间：2013-12-3
**/
package treadgame;
import java.util.Stack;
/**
* @author lcx
*
*/
public class Producer_Consumer1 {
public static void main(String[] args) {
Stack<String> apples=new Stack<String>();
Thread td1=new Thread(new Producer1("生产者1",apples));
Thread td2=new Thread(new Consumer1("消费者",apples));
td2.start();
td1.start();
}
}
class Producer1 implements Runnable
{
String name;
Stack<String> apples;
public Producer1(String name,Stack<String> apples)
{
this.name=name;
this.apples=apples;
}
public synchronized void produce(String apple) throws Exception
{
// System.out.println("生产者 此时一共"+apples.size()+"个APPLE");
if(apples.size()>=5)
{
System.out.println(name+"堵塞");
wait();
}
notify();
apples.push(apple);
System.out.println(name+"已经生产了"+apple);
}
public void run() {
for(int i=0;i<10;i++)
{
try {
produce("苹果"+i);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class Consumer1 implements Runnable
{
String name;
Stack<String> apples;
public Consumer1(String name,Stack<String> apples)
{
this.name=name;
this.apples=apples;
}
public synchronized void consume() throws Exception
{
// System.out.println("消费者 此时一共"+apples.size()+"个APPLE");
if(apples.size()==0)
{
System.out.println(name+"堵塞");
wait();
}
notify();
String apple=apples.pop();
System.out.println(name+"已经消费了"+apple);
}
public void run() {
for(int i=0;i<10;i++)
{
try {
consume();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
然后一直会出现死锁。细致思考后发现wait与notify出现的位置不对。wait的作用是运行wait的线程堵塞。然后释放对象锁；notify是唤醒改对象的其它线程。
所以wait方法与notify应该是相应的一个对象，而我在代码中却希望通过在Consumer中的wait唤醒Producer的对象。肯定是不对的。
结果改动后，例如以下
/**
* 项目名称：
* 文件说明：
* 主要特点：生产者消费者模式
* 版本：1.0
* 制作人：lcx
* 创建时间：2013-12-3
**/
package treadgame;
import java.util.Stack;
/**
* @author lcx
*
*/
public class Producer_Consumer2 {
public static void main(String[] args) {
Resturant res=new Resturant();
Thread td1=new Thread(new Producer2(res));
// Thread td2=new Thread(new Producer("生产者2",apples));
// Thread td3=new Thread(new Producer("生产者3",apples));
Thread td4=new Thread(new Consumer2(res));
td4.start();
td1.start();
// td2.start();
// td3.start();
}
}
class Resturant
{
Stack<String> apples=new Stack<String>();
public synchronized void produce(String apple) throws Exception
{
// System.out.println("生产者 此时一共"+apples.size()+"个APPLE");
if(apples.size()>=5)
{
System.out.println("生产堵塞");
wait();
}
notify();
apples.push(apple);
System.out.println("已经生产了"+apple);
}
public synchronized void consume() throws Exception
{
// System.out.println("消费者 此时一共"+apples.size()+"个APPLE");
if(apples.size()==0)
{
System.out.println("消费堵塞");
wait();
}
notify();
String apple=apples.pop();
System.out.println("已经消费了"+apple);
}
}
class Producer2 implements Runnable
{
Resturant res;
public Producer2(Resturant res)
{
this.res=res;
}
public void run() {
for(int i=1;i<=10;i++)
{
try {
res.produce("苹果"+i);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class Consumer2 implements Runnable
{
Resturant res;
Stack<String> apples;
public Consumer2( Resturant res)
{
this.res=res;
}
public void run() {
for(int i=1;i<=10;i++)
{
try {
res.consume();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
这样就能够了。
问题3 若produce与consume方法都不是同步方法，会出现什么问题？
会出现IllegalMonitorStateException异常。由于wait必须在同步代码块中。
总结：
就我如今的经验看来，分析多线程问题。应该分析的是资源，而不是线程。由于线程的运行是由他们与资源的关系所决定的。