synchronized & 生产者&消费者&死锁

 

使用synchronized 实现生产者和消费者，发现出现死锁，代码如下：

   （wait notify nofityAll 方法，只能在监控器对象（锁对象）上调用）。

 

 

public class BlockingListBySync<E> implements BlockingList<E> {
    static final int MAXIMUM_CAPACITY = 1 << 30;
     int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
    }
    Object items[]= null;
    volatile  int count = 0;
    int putIndex =0;
    int takeIndex = 0;
    public BlockingListBySync(int size){
        int realSize = tableSizeFor(size);
        items = new Object [realSize];
    }

    /**
     * 生产对象
     * @param e
     * @throws InterruptedException
     */
    @Override
    public   void put(E e) throws InterruptedException{
        synchronized (this){
            while(count ==items.length){
                    this.wait();
            }
            putIndex ++;
            putIndex = putIndex & (items.length-1);
            items[putIndex]= e;
            count++;
           this.notify();
        }
    }

    public int size(){
        return count;
    }

    /**
     * 消费对象
     * @return
     * @throws InterruptedException
     */
    @Override
    public E take() throws InterruptedException{
        synchronized (this){
            while(count ==0){

                this.wait();
            }
            takeIndex ++;
            takeIndex = takeIndex & (items.length-1);
            count--;
            E e = (E)items[takeIndex];

            items[takeIndex] = null;
            this.notify();
            return e;
        }
    }
}

   多个生产线程调用put方法。

 

  多个消费线程调用take方法。

   运行结果：产生死锁。

 

  原因分析：线程调用wait()方法之后，线程进入监控器对象的等待队列，那么在等待队列中即有生产者线程，也有消费都线程。当监控器对象的notify方被调用时，从等待队列中任意性选取一个线程唤醒，那么唤醒的线程 有可能是生产者线程，也有可能是消费者线程 。 如果生产线程唤醒的也是生产线程，那么很容易死锁。  

简单来说：就是等待队列中有2种线程，生产线程想唤醒消费线程，但jvm是任意选取线程唤醒的，如果换醒了生产线程，可能进入死锁。 

 

解决方法：

1.把nofity 换成notifyAll() 

      notifyAll()把监控器上等待队列中所有的线程唤醒，一定是包括了消费线程，所以可以。

 

2.可以使用ReentrantLock 创建两个Condition(空的和满的)，可以区分线程类型