Java 锁分离

[size=medium]
读写锁思想的延伸就是锁分离。读写锁根据读写操作功能上的不同，进行了有效的锁分离。依据应用程序的功能特点，使用类似的分离思想，也可以对独占锁进行分离。
一个典型的应用就是java.util.concurrent.LinkedBlockingQueue.

在LinkedBlockingQueue的实现中。take()和put()函数分别实现了从队列中获取数据和往队列中增加数据的功能。虽然这两个操作都是对当前队列进行修改操作，但由于LinkedBlockingQueue 是基于链表实现的，因此这两个操作分别对应这链表的前端和尾端，从理论上讲，这两个操作并不冲突。

如果使用独占锁，则要求在这两个操作进行时获取独占锁，那么这两个操作就不可能实现真正意义上的并发，激烈的锁竞争从而 影响系统性能。

在jdk中，并没有使用这种方式，取而代之的是 两把不同的锁分离了take()和put()操作。

[/size]

      /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock(); 

[size=medium]
以上代码定义了 takeLock 和 putLock ，他们分别对应着 take() 和 put()操作，take()和put()是相互独立的，take(0和take()竞争锁，put()和put()竞争锁。
[/size]

       public E take() throws InterruptedException {
        E x;
        int c = -1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lockInterruptibly();// 不允许同时读取锁
        try {
            try {
                while (count.get() == 0)
                    notEmpty.await();
            } catch (InterruptedException ie) {
                notEmpty.signal(); // propagate to a non-interrupted thread
                throw ie;
            }

            x = extract();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }

public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        // Note: convention in all put/take/etc is to preset
        // local var holding count  negative to indicate failure unless set.
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();//不允许同时修改锁
        try {
            /*
             * Note that count is used in wait guard even though it is
             * not protected by lock. This works because count can
             * only decrease at this point (all other puts are shut
             * out by lock), and we (or some other waiting put) are
             * signalled if it ever changes from
             * capacity. Similarly for all other uses of count in
             * other wait guards.
             */
            try {
                while (count.get() == capacity)
                    notFull.await();
            } catch (InterruptedException ie) {
                notFull.signal(); // propagate to a non-interrupted thread
                throw ie;
            }
            insert(e);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

[size=medium]
概念太多反而不易于理解，这里简单说下 锁分离和分段锁。
我们以ConcurrentHashMap 这种数据结构来分析，锁分离机制，就是把一个HashMap 分成很多个segement，对每一个segement的写操作上锁。他的get（）操作是没有锁的，具体思想就是把每个hash槽中的链表的头节点置成final的。对hash槽中链表操作，只能从头部去处理。这样就不会有读不一致的情况出现。这个原理，最好还是看源码，比较清晰。
[/size]