java生产者消费者问题总结
1. wait/notify方法实现
public class Test
{
private static Integer count = 0;
private final Integer FULL = 5; //定义生产5个时工作区满
private static String lock = "lock"; //定义锁
public static void main(String[] args)
{
Test t = new Test();
new Thread(t.new Producer()).start();
new Thread(t.new Consumer()).start();
new Thread(t.new Producer()).start();
new Thread(t.new Consumer()).start();
}
class Producer implements Runnable
{
@Override
public void run()
{
for (int i = 0; i < 5; i++)
{
synchronized (lock)
{
while (count == FULL)
{
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "produce:: " + count);
lock.notifyAll();
}
}
}
}
class Consumer implements Runnable
{
@Override
public void run()
{
for (int i = 0; i < 5; i++)
{
synchronized (lock)
{
while (count == 0)
{
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
count--;
System.out.println(Thread.currentThread().getName()+ "consume:: " + count);
lock.notifyAll();
}
}
}
}
}
2.synchronized
lock可以为任意变量,但生产者和消费者线程synchronized(lock)关键字中应为同一变量, 这样才能保证生产者和消费者竞争的为同一个锁,否则会出现生产者和消费者各自竞争的情况,无法保证生产者和消费者之间的同步。
3.wait和notify机制
首先考虑操作系统中一个线程从创建到被销毁的生命周期,经历五种状态
新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();
就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;
运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;
阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同,阻塞状态分为三种:
- 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
- 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
- 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
对一个线程调用wait方法后,该线程会被挂起,进入阻塞态1,释放同步锁,加入到当前资源的等待队列中。当其他线程调用 notify / notifyAll 方法时,当前等待队列全部线程被唤醒,竞争synchronized同步锁,竞争成功后进入Runnable,等待CPU,竞争同步锁失败进入阻塞态2,直到获取到同步锁进入到Runnable。
当生产者生产一个产品或消费者消费一个产品后,当前线程应该释放同步锁,一个不甚妥当的做法是,在此之后使用wait方法使线程进入阻塞态1,等待其他线程唤醒。如以下代码所示:
class Producer implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (lock){
while (count == FULL){
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "produce:: " + count);
lock.notifyAll();
try{
lock.wait();
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
事实上,当我们注释掉try{…}catch(){…}语句后,线程执行完lock.notifyAll()后退出synchronized片段,会自动释放同步锁,由其他线程竞争,无须特意添加wait使线程释放锁
4.生产区已满和为空时处理方法
当生产的产品数量达到full值,生产者应该停止生产,当产品数量为空时,消费者应该停止消费产品。
有两种处理方式,使用while语句判断和使用if-else判断。
使用while如第一部分,使用if-else代码如下
class Producer implements Runnable{
@Override
public void run(){
for (int i = 0; i < 5; i++){
synchronized (lock){
if (count == FULL){
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{
count++;
System.out.println(Thread.currentThread().getName() + "produce:: " + count);
lock.notifyAll();
}
}
}
}
}
class Producer implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (lock){
if (count == FULL){
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else{
count++;
System.out.println(Thread.currentThread().getName() + "produce:: " + count);
lock.notifyAll();
}
}
}
}
}
许多人在此可能犯错,我在此部分写下了这样的逻辑
class Producer implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (lock){
// if(count>FULL){
// System.out.println("产品数超出限制,数量为"+"count"+“-----------------------”);
// }
if (count == FULL){
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "produce:: " + count);
lock.notifyAll();
}
}
}
}
class Consumer implements Runnable
{
@Override
public void run()
{
for (int i = 0; i < 5; i++)
{
synchronized (lock)
{
if (count == 0)
{
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
count--;
System.out.println(Thread.currentThread().getName()+ "consume:: " + count);
lock.notifyAll();
}
}
}
}
当生产者生产块时,消费者消费慢时,解开注释部分的语句,会产生如下情况:通过控制台可以看到,明明生产者在检测到数量等于限制时会进入阻塞态,但生产者生产的数量还是超出了限制
产生的原因是,当程序执行wait后进入阻塞态,被唤醒后再次获得同步锁后,不会再次判断产品数量是否超出限制,而是会从被阻塞的地方继续执行程序。如,当生产者1和生产者2因为产品数量full被阻塞,当消费者消费后,生产者1和2同时被唤醒,1先竞争获得锁,生产一个产品,释放同步锁,此时产品数量已满,生产者2获得同步锁,不再检测数量是否已满,就会继续生产使产品数量超出限制,所以应该使用while语句再次检测数量是否已满,超出时阻塞生产者。
而使用if-else判断时,当生产者1和生产者2因为产品数量full被阻塞,当消费者消费后,生产者1和2同时被唤醒,1获得同步锁后不会执行else语句中的代码生产产品,而是继续运行释放同步锁,所以产品数量不会超出限制。
总结和思考
虽然生产者消费者是经典的多线程同步问题,分析起来也很简单,但在实际写的过程中我犯了不少错误,总体原因还是因为对wait/notify和synchronized机制一知半解,在以后的学习过程中不能仅仅只是了解使用,同时也要了解背后机制。