Java并发编程类学习五（同步工具）

内置锁（synchronized）

每个Java对象都对应有一个内置锁。有两种方式：第一种直接修饰方法；第二种synchronized后跟加锁的对象。
示范：

    public synchronized void doSomething(Object obj){
        synchronized(obj){
            //execute action
        }
    } 

CountDownLatch

CountDownLatch翻译为闭锁，是一种同步工具。CountDownLatch强调的是一个线程（或多个）需要等待另外的n个线程干完某件事情之后才能继续执行。
CountDownLatch使用countDown事件去控制并发。一般在用CountDownLatch的时候，对于同一个CountDownLatch对象，有两类线程：一类是在await，等待某个countDown事件发生，然后再执行后续操作；另一类完成了前期的准备工作，发起countDown事件。
参考我之前写的文章http://blog.csdn.net/csujiangyu/article/details/44236205。

CyclicBarrier

CyclicBarrier翻译为栅栏，也是一种同步工具。它允许多个线程（或者说一组线程）在一个屏障点相互等待，直到每个线程到到达屏障点。CyclicBarrier本身是用线程的await()方法控制并发，每个线程都会参与其中，等到最后到达屏障点的线程后才执行后续操作。

参考我之前写的文章http://blog.csdn.net/csujiangyu/article/details/44338307

信号量

用来控制访问或者操作某个特定资源的线程数量。常用来实现某种资源池，或者对容器施加边界。
如果要实现一个有界缓存，最多只能有指定个数的线程访问缓存，可以这么实现：

public class BoundedCache<K, V> {
    private static final int DEFAULT_SIZE = 10;

    private Map<K, V> cache;
    private final Semaphore sem;

    public BoundedCache(int capacity){
        this.sem = new Semaphore(capacity);
        this.cache = new ConcurrentHashMap<>() ;
    }

    public BoundedCache(){
        this(DEFAULT_SIZE);
    }

    public void put(K key, V value) throws InterruptedException{
        sem.acquire();

        try{
            cache.put(key, value);
        }finally{
            sem.release();
        }
    }

    public V get(K key) throws InterruptedException{
        sem.acquire();
        try{
            return cache.get(key);
        }finally{
            sem.release();
        }

    }
} 

ReentrantLock

一种显示锁，不同于内置锁，需要显示声明和使用。具体可参照我之前写的问题http://blog.csdn.net/csujiangyu/article/details/44002609

Condition

显示的Condition对象是一种更灵活的选择，提供了更丰富的功能：在每个锁上可以存在多个条件等待，条件等待可以是中断的或不可中断的，基于时限的等待，以及公平的或非公平的队列操作。可调用Lock.newCondition生成Condition对象。一个Lock可以有多个关联的Condition。

实现有界缓存：

public class ConditionBoundBuffer<V> {
    private final V[] buf;
    private int tail;
    private int head;
    private int count;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    @SuppressWarnings("unchecked")
    public ConditionBoundBuffer(int capacity) {
        buf = (V[]) new Object[capacity];
    }
    private void doPut(V v) {
        buf[tail] = v;
        if (++tail == buf.length)
            tail = 0;
        count++;
    }
    private V doTake() {
        V v = buf[head];
        if (++head == buf.length)
            head = 0;
        count--;
        return v;
    }
    public void put(V v) throws InterruptedException {
        lock.tryLock();
        try {
            while (count == buf.length) {
                notFull.await();// 等待直到notfull
            }
            doPut(v);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    public V get() throws InterruptedException {
        lock.tryLock();
        try {
            while (count == 0) {
                notEmpty.await();// 等待直到notEmpty
            }
            V v = doTake();
            notFull.signal();
            return v;
        } finally {
            lock.unlock();
        }
    }
}