Java里线程安全的有界容器的实现

1. 引言

这篇博客通过实现一个有界容器来表述Java里wait，notify，notifyAll的用法。这些关键词用的概率不高，但是阅读一些源码的时候还是经常会遇到，写一下增强记忆。

具体生产实践的时候，对于我来说我是不推荐程序员们直接使用这些的，JAVA1.5之后提供很多直接可用的线程安全的容器，能少写代码就少些代码，降低了测试的需求，

也减少出错的可能性。

2. 一个线程安全的容量有限的栈

先把代码贴上：

package com.sabo.concurrent;

/**
 * Created by canbin.zhang on 2016/3/29.
 */
public class SaboStack {
    private final int[] _data;

    public SaboStack(int limit) {
        _data = new int[limit];
    }

    private final Object lock = new Object();
    private int size = 0;

    public void push(int v) {
        synchronized (lock) {
            while (size >= _data.length) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            _data[size] = v;
            ++size;
            lock.notifyAll();
        }
    }

    public int pop() {
        int v;

        synchronized (lock) {
            while (size == 0) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            v = _data[size - 1];
            --size;
            lock.notifyAll();

            return v;
        }
    }
}

要是stack的容量无限的话，其实这里的实现只要synchronized关键词就能实现了，但是大部分情况下内存的使用总是受到限制，比如栈最多只能用10个int大小的空间，这样的话实现就需要多考虑一个逻辑“当栈里没元素怎么办？当栈的空间满了该怎么处理？”。

Java里给出了这样一个机制，当遇到了这种情况时调用wait方法导致该调用线程被放在等待队列里，当情况发生改变的时候（条件可能满足）被唤醒。

wait的使用方法基本采用一个固定的模式：

synchronized (lock) {
            while (/*条件*/) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
           
           //满足条件之后的其他处理代码

1). lock.wait()方法调用之后当前线程将放弃所占有的锁，这样其他线程就有机会改变目前的状态。

2). 注意判断条件满不满足使用while而不是if，这是因为当前线程被唤醒之后条件又不满足了。

3). notify 和 notifyAll的区别：notify唤醒等待队列里的一个线程， notifyAll唤醒等待队列里的所有线程，这能想到什么问题呢？ notify唤醒的线程无法改变条件怎么办，这样的话可能会导致死锁。

另外能想到的问题是： notify和notifyAll并没有说明哪些线程应该被唤醒，这样导致不该醒的线程又进入了等待队列，这将导致比较低的效率。

比如这里，我希望当stack的元素数量size >= 1的时候去唤醒那些因为stack空而被放在等待队列的线程。

class SaboStack2 {
    private final int[] _data;
    private int size = 0;

    public SaboStack2(int limit) {
        _data = new int[limit];
    }
    
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition lock_empty = lock.newCondition();
    private final Condition lock_full = lock.newCondition();
    
    public void push(int v) {
        lock.lock();
        while (size >= _data.length) {
            try {
                lock_full.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        _data[size] = v;
        ++size;
        lock_empty.signalAll();        
        lock.unlock();
    }
    
    public int pop() {
        int v;
        
        lock.lock();
        while (size == 0) {
            try {
                lock_empty.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        v = _data[size - 1];
        --size;
        lock_full.signalAll();       
        lock.unlock();
        
        return v;
    }            
}

这里采用Condition lock将那些等待的线程分为两组，有了区分度，能一定程度上提升效率。

如果你是Linux程序员熟悉pthread_cond_wait可能会更喜欢第二种的实现方式，但是应该还是看不习惯，弄出个等待队列这样的玩意儿怎么看都有些蛋疼。