Java多线程编程-ReentrantReadWriteLock 读写锁使用

ReentrantLock具有完全互斥的效果，每次只能有一个线程在执行lock方法后的任务。这样可以保证实例变量的线程安全性，但是效果不是很理想。假如我们多有线程都是读操作，没有写操作的时候就不需要其他线程去等待当前线程读取完，因为没有数据的变化，这样的话性能会有相应的提升。如果写操作的时候，就需要等待即可。我们可以使用 ReentrantReadWriteLock 类进行处理，ReentrantReadWriteLock 中有两个锁，一个是读取操作相关的锁，一个是写操作相关的锁。读操作的锁是共享锁，写操作是排他锁，这个是一个很正常的，不然多个线程编辑一个文件不就乱套了，哈哈。
所以可以得出以下结论：
1.多个读锁之间不互斥
2.读锁和写锁互斥
3.写锁和写锁互斥
4.写锁和读锁互斥

ReentrantReadWriteLock读锁与读锁不互斥

验证读锁和读锁不互斥：

public class ReentranReadWirteLockMain1 {

    public static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    testReadFun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Stream.of("thread01", "thread02", "thread03").forEach(s -> new Thread(runnable, s).start());
    }

    public static void testReadFun() throws InterruptedException {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " get read lock");
            Thread.sleep(5000);
            System.out.println("current thread name:" + Thread.currentThread().getName() + " read lock end");
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }
}

运行结果：

多个线程不会等待其他线程释放锁，先输出前三行，之后5秒之后输出后三行。说明启动的时候都可以获得读锁，不会等待。提升读取的效率，不会出现线程等待问题。

ReentrantReadWriteLock读锁与写锁互斥

验证一下一个线程读操作和另外一个写操作会不会互斥

public class ReentranReadWirteLockMain3 {

    public static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    testReadFun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                try {
                    testWriteFun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread thread = new Thread(runnable, "thread01");
        thread.start();
        Thread.sleep(1000);
        Thread thread2 = new Thread(runnable2, "thread02");
        thread2.start();

    }

    public static void testReadFun() throws InterruptedException {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " get read lock");
            System.out.println(System.currentTimeMillis());
            Thread.sleep(5000);
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }

    public static void testWriteFun() throws InterruptedException {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " get write lock");
            System.out.println(System.currentTimeMillis());
            Thread.sleep(5000);
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
}

运行结果：

我们看看结果，时间相隔5秒，这是怎么回事？这个是读锁与写锁互斥导致的，不会同时又进入写操作和读操作。

ReentrantReadWriteLock写锁与写锁互斥

验证一下一个线程写操作和另外一个写操作会不会互斥

public class ReentranReadWirteLockMain2 {

    public static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    testReadFun();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Stream.of("thread01", "thread02", "thread03").forEach(s -> new Thread(runnable, s).start());
    }

    public static void testReadFun() throws InterruptedException {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println("current thread name:" + Thread.currentThread().getName() + " get write lock");
            Thread.sleep(5000);
            System.out.println("current thread name:" + Thread.currentThread().getName() + " write lock end");
        } finally {
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
}

运行结果：

有运行结果可以看出，打印的时候最开始那个线程先获取锁就等待5秒输出current thread name: 线程名 read lock end，之后再运行获取锁的操作，有打印可以看出写操作是互斥操作

ReentrantReadWriteLock写锁与读锁互斥

上面读锁和写锁互斥，其实反过来也是一样的。

Thread thread2 = new Thread(runnable2, "thread02");
thread2.start();
Thread.sleep(1000);
Thread thread = new Thread(runnable, "thread01");
thread.start();

运行结果：

证明写锁和读锁也是互斥的。
我们来看看读操作和写操作互斥原理：
源码：
ReentrantReadWriteLock也会有公平锁和非公平锁之分，和ReentrantLock一致，但是就是会有读锁和写锁的处理。

 //一个读锁
 private final ReentrantReadWriteLock.ReadLock readerLock;
 //一个写锁
 private final ReentrantReadWriteLock.WriteLock writerLock;

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

读锁实现核心代码：

//以共享模式获取，忽略中断。通过首先至少调用一次tryAcquireShared并成功返回来实现。
//否则，线程将排队，并可能反复阻塞和解除阻塞，并调用tryAcquireShared直到成功。
public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

tryAcquireShared()方法：

//如果另一个线程持有写锁定，则失败。 否则，此线程有资格进入锁定wrt状态，
//因此请问是否由于队列策略而应阻塞。如果不是，请尝试按CASing状态授予许可并更新计数。
//请注意，此步骤不会检查重入获取，这会推迟到完整版本，以避免在更典型的非重入情况下必须检查保留计数。 
//如果第2步失败，或者由于线程显然不符合条件或者CAS失败或计数饱和，请使用完全重试循环链接到版本。
 protected final int tryAcquireShared(int unused) {
    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);
}

fullTryAcquireShared()方法：

 final int fullTryAcquireShared(Thread current) {
    HoldCounter rh = null;
    for (;;) {
        int c = getState();
        if (exclusiveCount(c) != 0) {
            if (getExclusiveOwnerThread() != current)
                return -1;
            //否则我们将持有排他锁；在此处阻塞将导致死锁。
        } else if (readerShouldBlock()) {
            // 确保我们没有重新获取读锁
            if (firstReader == current) {
                // 断言firstReaderHoldCount> 0
            } else {
                if (rh == null) {
                    rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current)) {
                        rh = readHolds.get();
                        if (rh.count == 0)
                            readHolds.remove();
                    }
                }
                if (rh.count == 0)
                    return -1;
            }
        }
        if (sharedCount(c) == MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        if (compareAndSetState(c, c + SHARED_UNIT)) {
            if (sharedCount(c) == 0) {
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                if (rh == null)
                    rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                else if (rh.count == 0)
                    readHolds.set(rh);
                rh.count++;
                cachedHoldCounter = rh; // cache for release
            }
            return 1;
        }
    }
}

写锁实现核心代码：

//在独占模式下获取，忽略中断。通过至少调用一次tryAcquire并成功返回来实现
//否则，线程将排队，并可能反复阻塞和解除阻塞，并调用tryAcquire直到成功
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected final boolean tryAcquire(int acquires) {
    //如果读取计数为非零或写入计数为非零，并且所有者是另一个线程，则失败。 
    //如果计数将饱和，则失败。 （只有在count已经不为零时，才可能发生这种情况。）
    //否则，如果该线程是可重入获取或队列策略允许的话，则有资格进行锁定。如果是这样，请更新状态并设置所有者。
    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;
}