多线程--生产者与消费者模式

对于单个生产者和单个消费者模式，可以使用wiat与notify来进行解决。

使用一个变量isproduce来标记当前是否生产了产品，如果isproduce为true，那么说明当前已经有一个产品生产好了，此时生产产品的线程应该wait，消费的线程应该被重新启动，反之，如果isproduce为false，那么此时说明没有产品生产，生产的线程应该启动，消费的线程应该wait。

代码如下：

package Thread;

import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;

import org.omg.CORBA.PUBLIC_MEMBER;

@SuppressWarnings("all")
class Test {
	public static Object LOCK = new Object();

	public volatile boolean isproduce = false;    //用来标记当前是否有产品产生
	public static int i = 0;

	public void produce() {
		synchronized (LOCK) {
			if (isproduce) {
				try {
					LOCK.wait();   //如果还有产品没有被消费，生产的线程应该wait
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				i++;
				System.out.println("P->" + i);
				isproduce = true;
				LOCK.notify();   //主要是唤醒消费的线程。
			}
		}
	}

	public void consume() {
		synchronized (LOCK) {
			if (isproduce) {
				System.out.println("C->" + i);   //有产品就消费
				isproduce = false;
				LOCK.notify();                    //消费完之后唤醒生产的线程
			} else {
				try {
					LOCK.wait();              //没有产品可以消费，那就等待产品产生。
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

public class Main {
	public static void main(String[] args) {
		Test x1 = new Test();
		new Thread() {
			@Override
			public void run() {
				while (true)
					x1.produce();
			};
		}.start();
		
		new Thread() {
			@Override
			public void run() {
				while(true) {
					while(true)
						x1.consume();
				}
			};
		}.start();
	}

}

 

那么这是单个消费者与单个生产者，在现实生活中消费者是多个的，生产者是多个的，那么用上面的那种模式还以可以吗？

答案是否定的，假设有两个生产者和两个消费者，代码如下：

package Thread;

import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;

import org.omg.CORBA.PUBLIC_MEMBER;

@SuppressWarnings("all")
class Test {
	public static Object LOCK = new Object();

	public volatile boolean isproduce = false;
	public static int i = 0;

	public void produce() {
		synchronized (LOCK) {
			if (isproduce) {
				try {
					LOCK.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				i++;
				System.out.println("P->" + i);
				isproduce = true;
				LOCK.notify();
			}
		}
	}

	public void consume() {
		synchronized (LOCK) {
			if (isproduce) {
				System.out.println("C->" + i);
				isproduce = false;
				LOCK.notify();
			} else {
				try {
					LOCK.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

public class Main {
	public static void main(String[] args) {
		Test x1 = new Test();
		for (int i = 1; i <= 2; i++) {     //两个生产者
			new Thread() {

				@Override
				public void run() {
					while (true)
						x1.produce();
				};
			}.start();
		}
		for (int i = 1; i <= 2; i++) {     //两个消费者
			new Thread() {       

				@Override
				public void run() {
					while (true) {
						while (true)
							x1.consume();
					}
				};
			}.start();
		}
	}

}

 

那么上述代码运行的结果是：

这种情况并不是死锁，而是出现了假死的现象，那么为什么会出现这种情况呢？

分析原因如下：

我们把上述代码输出结果加上线程的名称就好理解了：

P0：第一个生产者。

P1：第二个生产者。

C0：第一个消费者。

C1：第二个消费者。

 

对于第一个产品来说，由P0生产，接着由C0消费，此时等待的队列有{P1，C1}，接着有P0生产第二件产品，由C1来消费，此时等待的队列中有：{P1，C0},接着有P1生产第三件产品，然后此时等待队列中就含有{P0，C0，C1}，接着在P1生产完第三件产品之后，如果唤醒的是P0的话，就会出现假死的状况，我们接着来分析为啥，唤醒P0之后，接着由于isproduce是true，P0就会进入wait状态，而之前的P1由于isproduce的状态也为true(也就是由于没有消费的线程被唤醒，所有的生产的线程最终都会进入到wait状态)，同样会进入wait状态，到现在为止，所有的线程都进入到了wait状态下，都不会去占用CPU，程序就卡在了这（当然我认为还有另一种情况，就是最后一步是消费线程，当消费者线程滑行的时候，唤醒的是另一个消费者线程，那么最终也会出现假死的现象），

 

那怎么解决这个问题呢？

既然是由于生产的线程或者消费的线程没有被及时的唤醒，那么可以采用notifyAll来唤醒LOCK对象锁池中等待的线程，就不会出现上述的情况了。

代码如下:

package Thread;

import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;

import org.omg.CORBA.PUBLIC_MEMBER;

@SuppressWarnings("all")
class Test {
	public static Object LOCK = new Object();

	public volatile boolean isproduce = false;
	public static int i = 0;

	public void produce() {
		synchronized (LOCK) {
			if (isproduce) {
				try {
					LOCK.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				i++;
				System.out.println("P *" + Thread.currentThread().getName() + "   " + i);
				isproduce = true;
				LOCK.notifyAll();
			}
		}
	}

	public void consume() {
		synchronized (LOCK) {
			if (isproduce) {
				System.out.println("C *" + Thread.currentThread().getName() + "   " + i);
				isproduce = false;
				LOCK.notifyAll();
			} else {
				try {
					LOCK.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

public class Main {
	public static void main(String[] args) {
		Test x1 = new Test();
		for (int i = 1; i <= 2; i++) {
			new Thread() {

				@Override
				public void run() {
					while (true)
						x1.produce();
				};
			}.start();
		}
		for (int i = 1; i <= 2; i++) {
			new Thread() {

				@Override
				public void run() {
					while (true) {
						while (true)
							x1.consume();
					}
				};
			}.start();
		}
	}

}

 

如果写的有问题，还请博主们指出。