读写锁ReentrantReadWriteLock
读线程与读线程之间不互斥
public interface ReadWriteLock {Lock readLock();Lock writeLock();}
ReentrantReadWriteLock实现了这个接口
ReentrantReadWriteLock的使用方法
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();Lock readLock = readWriteLock.readLock();readLock.lock();readLock.unlock();Lock writeLock = readWriteLock.writeLock();writeLock.lock();writeLock.unlock();
ReentrantReadWriteLock的实现
构造方法
public ReentrantReadWriteLock() {//是否公平this(false);}public ReentrantReadWriteLock(boolean fair) {//使用公平或者非公平的syncsync = fair ? new FairSync() : new NonfairSync();//readerLock 和writerLock 使用同一个syncreaderLock = new ReadLock(this);writerLock = new WriteLock(this);}
读写锁和互斥锁一样也是用state来表示锁的状态的，只是操作方式不同
abstract static class Sync extends AbstractQueuedSynchronizer {//...static final int SHARED_SHIFT = 16;static final int SHARED_UNIT = (1 << SHARED_SHIFT);static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;//int的长度是32位，这里会把state作为参数传入，然后取state的高16位static int sharedCount(int c) {return c >>> SHARED_SHIFT; }//取state的低16位static int exclusiveCount(int c) {return c & EXCLUSIVE_MASK; }//...}
ReentrantReadWriteLock会把state变量拆成两半，低16位，用来记录写锁。如果低16位的值等于5，表示一个写线程重入了5次。高16位，用来记录读锁。例如，高16位的值等于5，既可以表示5个读线程都拿到了该锁；也可以表示一个读线程重入了5次
当state=0时，说明既没有线程持有读锁，也没有线程持有写锁；当state != 0时，要么有线程持有读锁，要么有线程持有写锁，两者不能同时成立，因为读和写互斥。这时再进一步通过sharedCount(state)和exclusiveCount(state)判断到底是读线程还是写线程持有了该锁。
ReentrantReadWriteLock的两个内部类ReadLock和WriteLock中使用state变量
public static class ReadLock implements Lock, java.io.Serializable {private final Sync sync;protected ReadLock(ReentrantReadWriteLock lock) {sync = lock.sync;}public void lock() {sync.acquireShared(1);}public void unlock() {sync.releaseShared(1);}}public static class WriteLock implements Lock, java.io.Serializable {private final Sync sync;protected WriteLock(ReentrantReadWriteLock lock) {sync = lock.sync;}public void lock() {sync.acquire(1);}public void unlock() {sync.release(1);}}
acquire/release、acquireShared/releaseShared 是AQS里面的两对模板方法。
public final void acquireShared(int arg) {//由AQS的子类sync实现if (tryAcquireShared(arg) < 0)//获得锁失败把自己加入等待获取锁队列，阻塞线程等待唤醒doAcquireShared(arg);}public final boolean releaseShared(int arg) {//由AQS的子类sync实现if (tryReleaseShared(arg)) {//唤醒挂起的线程doReleaseShared();return true;}return false;}public final void acquire(int arg) {//由AQS的子类sync实现if (!tryAcquire(arg) &&//获得写锁失败把自己加入阻塞队列acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//响应中断selfInterrupt();}public final boolean release(int arg) {//由AQS的子类sync实现if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)//唤醒线程unparkSuccessor(h);return true;}return false;}
ReentrantReadWriteLock中的sync
//非公平的syncstatic final class NonfairSync extends Sync {private static final long serialVersionUID = -8159625535654395037L;//写线程是否应该阻塞final boolean writerShouldBlock() {//非公平锁不阻塞return false;}//读线程是否应该阻塞final boolean readerShouldBlock() {//队列中第一个是写线程则阻塞return apparentlyFirstQueuedIsExclusive();}}//公平的syncstatic final class FairSync extends Sync {private static final long serialVersionUID = -2274990926593161451L;//写线程是否应该阻塞final boolean writerShouldBlock() {//如果队列中已经有线程在排队则阻塞return hasQueuedPredecessors();}//读线程是否应该阻塞final boolean readerShouldBlock() {return hasQueuedPredecessors();}}
写锁的实现
public boolean tryLock( ) {return sync.tryWriteLock();}final boolean tryWriteLock() {Thread current = Thread.currentThread();//获得stateint c = getState();//当state不等于0的时候说明有线程获取了锁if (c != 0) {//获得写线程的数量int w = exclusiveCount(c);//如果写线程==0说明持有锁的是读线程，或者当前线程不是排它锁的持有线程if (w == 0 || current != getExclusiveOwnerThread())return false;if (w == MAX_COUNT)throw new Error("Maximum lock count exceeded");}//cas将state+1重入if (!compareAndSetState(c, c + 1))return false;//设置排它锁的持有线程为当前线程setExclusiveOwnerThread(current);return true;}//lock的时候调用tryAcquire，这里是fair的syncprotected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {//前面没有其他线程if (!hasQueuedPredecessors() &&//cas设置state为acquirescompareAndSetState(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;}public void unlock() {sync.release(1);}public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;//唤醒队列里面的第一个线程if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;}
读锁的实现
public boolean tryLock() {return sync.tryReadLock();}final boolean tryReadLock() {Thread current = Thread.currentThread();for (;;) {int c = getState();//如果排它锁的持有线程是写线程，并且当前线程不是持有锁线程if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current)return false;//获得读锁的stateint r = sharedCount(c);if (r == MAX_COUNT)throw new Error("Maximum lock count exceeded");//cas设置读锁if (compareAndSetState(c, c + SHARED_UNIT)) {//如果r=0说明当前线程是第一个读线程if (r == 0) {firstReader = current;firstReaderHoldCount = 1;//第一个读线程是当前线程} else if (firstReader == current) {firstReaderHoldCount++;} else {// 如果firstReader不是当前线程，则从ThreadLocal中获取当前线程的读锁个数，并设置当前线程持有的读锁个数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 true;}}}public void lock() {sync.acquireShared(1);}public final void acquireShared(int arg) {if (tryAcquireShared(arg) < 0)//获取锁失败，将当前线程加入阻塞队列doAcquireShared(arg);}public void unlock() {sync.releaseShared(1);}public final boolean releaseShared(int arg) {//cas设置读线程的stateif (tryReleaseShared(arg)) {//唤醒线程doReleaseShared();return true;}return false;}
「爱情、让人受尽委屈。」
柔情只为你懂
╰+攻爆jí腚メ
r囧r小猫
小灰灰
我就是我
红太狼
还没有评论，来说两句吧...