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

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();
        }
    }