并发编程学习笔记(6)----公平锁和ReentrantReadWriteLock使用及原理

（一）公平锁

　　1、什么是公平锁？

　　公平锁指的是在某个线程释放锁之后，等待的线程获取锁的策略是以请求获取锁的时间为标准的，即使先请求获取锁的线程先拿到锁。

　　2、在java中的实现？

　　在java的并发包中提供了ReentrantLock提供了重入锁并且也提供了公平锁（FairSync）和非公平锁（NonfairSync）。

　　RenntranLock类的构造方法可传入一个boolean值作为标记是否是否用公平锁，默认是非公平的，非公平锁我们与我们之前学习时实现的可重入锁原理相似，这里就不再详说，接下来看看公平锁的源码：

 protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

FairSync重写了AQS中的tryAcquire()方法，跟我们前面的知识点中的需要什么要的锁就重写tryXX方法吻合。这里看代码。

可以看到这里跟我们前两两章学习到的非公平锁的实现只多了一个hasQueuePredecessors()方法的判断，这个方法就是判断当前线程的前一个线程是否也有资格去获取锁，只有没有资格获取锁时，当前的线程才可以返回true.否则就不能获取锁，接下来看看hasQueuePredecessors()方法：

public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

这段代码表示如果当链表为空时，是肯定可以获取的锁的，所以h!=t返回false，前面的方法会继续向下执行，链表不为空时，当头节点的下一个节点为空时，没有可以执行的线程，不能获取锁，当头节点的下一个节点不为空时，但是头节点的下一个节点的线程不等于当前线程，这样也是不能获取的，表示当前线程的前面还有先进来的线程在等待，所以不能获取锁，这样实现了一个公平锁。公平锁的使用只需要在实例化ReentrantLock的时候传入true即可。

（二）读写锁(ReentrantReadWriteLock)的使用及原理。

　　1、什么是读写锁？

　　在实际的应用中，读的操作是远远大于写操作的，并且读操作是不会产生线程安全问题的，如果我们给读和写的所有线程都加上互斥锁，那么在读的过程中会影响很大的性能，所以在java中提供了读写锁，读写锁分为读锁和写锁，其中读锁和读锁共享，读锁和写锁互斥，写锁和写锁互斥，这也是前面AQS的独享和共享模式的具体实现。

　　2、读写锁的运用方式

　　直接上代码：

package com.wangx.thread.t5;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Demo {

    private Map<String,Object> map = new HashMap<>();

    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock write = readWriteLock.writeLock();
    private Lock read = readWriteLock.readLock();
    public Object get (String key) {
        read.lock();
        System.out.println(Thread.currentThread().getName() + "读操作在执行...");
        try {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return map.get(key);
        } finally {
           read.unlock();
            System.out.println(Thread.currentThread().getName() + "读操作执行完毕...");
        }
    }

    public void put(String key, Object value) {
        write.lock();
        System.out.println(Thread.currentThread().getName() + "写操作在执行...");
        try {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
        } finally {
            write.unlock();
            System.out.println(Thread.currentThread().getName() + "写操作执行完毕...");
        }

    }

}

由于hashMap是线程不安全的，但是又是需要读写都进行的，所以使用map的get和put方法可以很好的模拟线程安全问题和读写锁的使用，运用很简单，就是在线实例化ReentrantReadWriteLock，在通过该对象分别获取读写锁，在读的地方加上读锁，写的地方加上写锁。

　　3、读写锁源码实现

　　首先获取看写锁源码：

 public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }

ReentrantReadWriteLock的writeLock方法返回writeLock，在构造方法中又实例化了WriterLock,WriteLock是ReentrantReadWriteLock的内部类，实现了Lock接口，保证了锁的所有方法的功能。再看WriteLock中的lock方法，

 public void lock() {
            sync.acquire(1);
        }

ReentrantReadWriteLock的内部帮助器，所以这里调用的实际上是外部类的Sync内部类，接着进入该类的acquire()方法：

protected final boolean tryAcquire(int acquires) {
            /*
             * Walkthrough:
             * 1. If read count nonzero or write count nonzero
             *    and owner is a different thread, fail.
             * 2. If count would saturate, fail. (This can only
             *    happen if count is already nonzero.)
             * 3. Otherwise, this thread is eligible for lock if
             *    it is either a reentrant acquire or
             *    queue policy allows it. If so, update state
             *    and set owner.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 0)
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // Reentrant acquire
                setState(c + acquires);
                return true;
            }
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

继承AQS框架的实现都是通过操作state来进行锁的获取和释放，所以getState()方法就不说了，接下来看看exclusiveCount（）方法：

static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

这里是通过十六位来保存读锁和写锁的，高8位保存写锁，低八位保存读锁，exclusiveCount（）传入1时返回值为本身。表示当前只能有一个线程持有独享锁。c等于0时，第一个线程第一次进来，操作和原理与之前的自己实现锁类似，就不详细说了，当c不等于0时，表示此时是有线程在执行的，但是w等于0则表示当前执行的是持有共享锁的县城，或者当前线程不是重入线程的情况下，返回false,获取线程失败，并且当写线程个数操过了最大数，也会获取锁失败，否则更改状态，返回true，获取重入锁成功。这就是写锁的实现，就是判断在写线程的情况下是否有其他线程在使用锁。

　　写线程的unlock也是调用WriteLock的中的unlock,最后调用sync中的tryRelease方法，所以重点来看tryRelease方法：

protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

当线程释放时，先判断，如果不是独享线程，肯定是有异常的，直接抛出异常，这个释放方法只能是独享线程来调用，做重线程的减减操作，当持有锁的线程为0，切重入锁为0时，释放锁，更改状态。完成写锁的释放。

　　读锁的实现源码，前面说过，读锁就是AQS的共享模式的具体运用，跟写锁类似，我们直接在ReentrantReadWriteLock的内部类的Sync中找到tryAcquireShared()方法：

protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail.
             * 2. Otherwise, this thread is eligible for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 3. If step 2 fails either because thread
             *    apparently not eligible or CAS fails or count
             *    saturated, chain to version with full retry loop.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return -1;
            int r = sharedCount(c);
            if (!readerShouldBlock() &&
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    rh.count++;
                }
                return 1;
            }
            return fullTryAcquireShared(current);
        }

第一步：判断是否有线程持有独享锁的存在，即exclusiveCount不为0，并且当前锁不是独享锁，返回-1表示获取锁失败。

第二步：获取持有共享锁的线程数量，readerShouldBlock()线程公平的判断，判断当前持有共享锁的线程是否小于最大线程数，是更改状态。

第三步：当r等于0时，表示当前线程是第一个，则将第一个线程保存，并将第一个线程的重入次数计为1。如果进来的线程是第一个的线程的重入，则重入次数加1。

第四步：HoldCounter用来保存持有持有共享锁的线程个数及线程id，当第二个能共享的线程进入时，rh==null时，readHolds获取到当前线程，readHolds通过ThreadLocal<HoldCounter> 保证线程安全。

第五步：当rh != null 时，且rh.tid != getThreadId(current)，即缓存的线程不是当前线程，即是进来的一个新的持共享锁的线程，则也获取当前线程的信息存到cachedHoldCounter中。

第六步：以上条件不成立时，表示是一个重入线程进入，当他的重入次数为0,表示第一次进入，将其添加到readHolds中，并将count++记录某个线程重入的次数，这样就能保证存入的共享线程个数和每个线程重入的次数。所有操作成功，则放回1，表示获取锁成功，否则fullTryAcquireShared（）对获取失败的各种原因进行处理，最后返回结果。

　　tryReleaseShared（）方法：

 protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            if (firstReader == current) {
                // assert firstReaderHoldCount > 0;
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;
                if (compareAndSetState(c, nextc))
                    // Releasing the read lock has no effect on readers,
                    // but it may allow waiting writers to proceed if
                    // both read and write locks are now free.
                    return nextc == 0;
            }
        }

这里只分析跟独享锁不同的部分，如果当前线程是第一个进来的共享线程，且重入次数为1时，释放该线程的共享锁，否则重入次数减1，当前线程不等于缓存的线程时，获取readholds中的线程，得到获取到的线程冲入次数，当小于等于1时移除该线程，也就是释放该线程锁，小于等于0时抛出异常，不为1时则重入次数减减，当持有共享锁的所有线程都移除后，不断自旋，直到成功释放锁，返回状态nextc是否为0。表示该锁是否可以释放。这样就成功地释放了共享锁。

（三）这里有个降级锁，就是在读和写可能在同一个操作中是，我们需要将写锁降级为读锁，以保证线程安全，示例代码：

package com.wangx.thread.t6;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Demo {

    private Map<String,Object> map = new HashMap<>();

    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock write = readWriteLock.writeLock();
    private Lock read = readWriteLock.readLock();
    private volatile boolean isUpdate;

    public void readWrite() {
        read.lock();
        if (isUpdate) {
            read.unlock();
            write.lock();
            map.put("xxx", "xxx");
            read.lock();
            write.unlock();
        }
        Object object = map.get("xxx");
        System.out.println(object);
        read.unlock();
    }
}

以上就是读写锁和公平锁我所了解的知识，今天的分享就到此为止，不足之处，忘各位指出。