并发编程--读写锁ReadWriteLock和ReentrantReadWriteLock（一）

比眉伴天荒 2022-06-17 08:07 184阅读 0赞

Java并发编程包提供了读写锁的实现，其维护了一对相关的锁 — — “读取锁”和“写入锁”，一个用于读取操作，另一个用于写入操作。

“读取锁”用于只读操作，它是“共享锁”，能同时被多个线程获取。

“写入锁”用于写入操作，它是“独占锁”，写入锁只能被一个线程锁获取。

ReadWriteLock是一个接口。ReentrantReadWriteLock是它的实现类，ReentrantReadWriteLock包括子类ReadLock和WriteLock。

读写锁接口ReadWriteLock：

（1）readLock获取一个读锁

（2）writeLock获取一个写锁

public interface ReadWriteLock {
    
        Lock readLock();
    
        Lock writeLock();
    }

在实现类ReentrantReadWriteLock中并发编程包分别实现了一个读锁ReadLock和写锁WriteLock，其实ReadLock和WriteLock差别不大，比较明显的差别是ReadLock获取锁时是调用acquireShared方法

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

WriteLock获取锁的方法是sync.acquire(1)

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

我们知道读锁是一个共享锁，写锁是一个独占锁，具体的实现区别应该是在acquireShared和acquire中体现的。

读锁ReadLock源码：

public static class ReadLock implements Lock, java.io.Serializable {
            private static final long serialVersionUID = -5992448646407690164L;
            private final Sync sync;
            protected ReadLock(ReentrantReadWriteLock lock) {
                sync = lock.sync;
            }
            public void lock() {
                sync.acquireShared(1);
            }
            public void lockInterruptibly() throws InterruptedException {
                sync.acquireSharedInterruptibly(1);
            }
            public boolean tryLock() {
                return sync.tryReadLock();
            }
            public boolean tryLock(long timeout, TimeUnit unit)
                    throws InterruptedException {
                return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
            }
            public void unlock() {
                sync.releaseShared(1);
            }
            public Condition newCondition() {
                throw new UnsupportedOperationException();
            }
            public String toString() {
                int r = sync.getReadLockCount();
                return super.toString() +
                    "[Read locks = " + r + "]";
            }
        }

写锁WriteLock源码：

public static class WriteLock implements Lock, java.io.Serializable {
            private static final long serialVersionUID = -4992448646407690164L;
            private final Sync sync;
    
            protected WriteLock(ReentrantReadWriteLock lock) {
                sync = lock.sync;
            }
    
           
            public void lock() {
                sync.acquire(1);
            }
    
           
            public void lockInterruptibly() throws InterruptedException {
                sync.acquireInterruptibly(1);
            }
    
            public boolean tryLock( ) {
                return sync.tryWriteLock();
            }
    
            
            public boolean tryLock(long timeout, TimeUnit unit)
                    throws InterruptedException {
                return sync.tryAcquireNanos(1, unit.toNanos(timeout));
            }
    
           
            public void unlock() {
                sync.release(1);
            }
    
            
            public Condition newCondition() {
                return sync.newCondition();
            }
    
           
            public String toString() {
                Thread o = sync.getOwner();
                return super.toString() + ((o == null) ?
                                           "[Unlocked]" :
                                           "[Locked by thread " + o.getName() + "]");
            }
    
            
            public boolean isHeldByCurrentThread() {
                return sync.isHeldExclusively();
            }
    
            
            public int getHoldCount() {
                return sync.getWriteHoldCount();
            }
        }