Davids原理探究：Java并发包中锁的原理（ReentrantLock、ReentrantReadWriteLock）

水深无声 2023-02-18 01:56 97阅读 0赞

### 文章目录 ###

*   *  Java并发包中锁的原理（ReentrantLock、ReentrantReadWriteLock）
     *   *  ReentrantLock公平锁
         *  ReentrantLock非公平锁
         *  abstract class AbstractQueuedSynchronizer - hasQueuedPredecessors实现
         *  ReentrantLock抽象类sync
         *  CopyOnWriteArrayList内部由ReentrantLock加锁实现线程安全

## Java并发包中锁的原理（ReentrantLock、ReentrantReadWriteLock） ##

// 独占锁（可重入）
    ReentrantLock fairLock = new ReentrantLock();
    // 独占公平锁
    ReentrantLock fairLock = new ReentrantLock(true);
    // 独占非公平锁
    ReentrantLock nonFairLock = new ReentrantLock(false);
    
    // 读写锁（可重入）
    ReentrantReadWriteLock fairReentrantReadWriteLock = new ReentrantReadWriteLock();
    // 公平读写锁
    ReentrantReadWriteLock fairReentrantReadWriteLock = new ReentrantReadWriteLock(true);
    // 共享读
    ReentrantReadWriteLock.ReadLock readLock = fairReentrantReadWriteLock.readLock();
    // 独占写
    ReentrantReadWriteLock.WriteLock writeLock = fairReentrantReadWriteLock.writeLock();
    // 非公平读写锁
    ReentrantReadWriteLock nonFairReentrantReadWriteLock = new ReentrantReadWriteLock(false);
    // 共享读
    ReentrantReadWriteLock.ReadLock readLock = nonFairReentrantReadWriteLock.readLock();
    // 独占写
    ReentrantReadWriteLock.WriteLock writeLock = nonFairReentrantReadWriteLock.writeLock();
    
    // JDK8新增锁（不可重入）
    StampedLock stampedLock = new StampedLock();
    // 独占写类似于ReentrantReadWriteLock
    long writeStamp = stampedLock.writeLock();
    // 悲观读，CAS获取锁
    long readStamp = stampedLock.readLock();
    // 乐观读，不加锁（读时检查当前是否有写锁，没有则返回非0的stamp，然后读取所需的值入栈，使用前校验stampedLock.validate(stamp)，期间是否有线程获取过写锁，此过程不加锁适合读多写少的场景，效率高，存在一致性问题，如果校验过后在操作的时候有线程获取写锁，并修改数据，则当前线程所获取的副本，会存在不一致，若无法接受，则需使用悲观锁。）
    long stamp = stampedLock.tryOptimisticRead();

### ReentrantLock公平锁 ###

static final class FairSync extends Sync {
        
        private static final long serialVersionUID = -3000897897090466540L;
    
        final void lock() {
        
            acquire(1);
        }
    
        protected final boolean tryAcquire(int acquires) {
        
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
        
    			// !hasQueuedPredecessors()判断队列中是否有前置节点，如果有则放弃
                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;
        }
    }

### ReentrantLock非公平锁 ###

static final class NonfairSync extends Sync {
        
       private static final long serialVersionUID = 7316153563782823691L;
    
       final void lock() {
        
    	// 不判断是否有前置节点，根据cpu自行分配时间片执行获取锁
           if (compareAndSetState(0, 1))
               setExclusiveOwnerThread(Thread.currentThread());
           else
               acquire(1);
       }
    
       protected final boolean tryAcquire(int acquires) {
        
           return nonfairTryAcquire(acquires);
       }
    }

### abstract class AbstractQueuedSynchronizer - hasQueuedPredecessors实现 ###

public final boolean hasQueuedPredecessors() {
        
        // 正确性取决于head是否在tail之前初始化，以及head.next是否正确（如果当前线程在队列中）
        Node t = tail; // 以相反的初始化顺序读取字段
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

### ReentrantLock抽象类sync ###

/** 
     * 此锁的同步控制基础。在下面将细分为公平和非公平版本。使用AQS状态来表示锁的保留数。
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        
       private static final long serialVersionUID = -5179523762034025860L;
    
       /**
        * 执行{@link Lock＃lock}。子类化的主要原因是为非公平版本提供了快速路径。
        */
       abstract void lock();
    
       /**
        * 执行不公平的tryLock。 tryAcquire是在子类中实现的，但是都需要对trylock方法进行不公平的try。
        */
       final boolean nonfairTryAcquire(int acquires) {
        
           final Thread current = Thread.currentThread();
           int c = getState();
           if (c == 0) {
        
               if (compareAndSetState(0, acquires)) {
        
                   setExclusiveOwnerThread(current);
                   return true;
               }
           }
           else if (current == getExclusiveOwnerThread()) {
        
               int nextc = c + acquires;
               if (nextc < 0) // overflow
                   throw new Error("Maximum lock count exceeded");
               setState(nextc);
               return true;
           }
           return false;
       }
    
       protected final boolean tryRelease(int releases) {
        
           int c = getState() - releases;
           if (Thread.currentThread() != getExclusiveOwnerThread())
               throw new IllegalMonitorStateException();
           boolean free = false;
           if (c == 0) {
        
               free = true;
               setExclusiveOwnerThread(null);
           }
           setState(c);
           return free;
       }
    
       protected final boolean isHeldExclusively() {
        
           // 虽然我们通常必须在拥有者之前先读取状态，但无需检查当前线程是否为拥有者
           return getExclusiveOwnerThread() == Thread.currentThread();
       }
    
       final ConditionObject newCondition() {
        
           return new ConditionObject();
       }
    
       // 从外部类继承的方法
    
       final Thread getOwner() {
        
           return getState() == 0 ? null : getExclusiveOwnerThread();
       }
    
       final int getHoldCount() {
        
           return isHeldExclusively() ? getState() : 0;
       }
    
       final boolean isLocked() {
        
           return getState() != 0;
       }
    
       /**
        * 从流中重构实例（即反序列化它）。
        */
       private void readObject(java.io.ObjectInputStream s)
           throws java.io.IOException, ClassNotFoundException {
        
           s.defaultReadObject();
           setState(0); // 重置为解锁状态
       }
    }

### CopyOnWriteArrayList内部由ReentrantLock加锁实现线程安全 ###

final transient ReentrantLock lock = new ReentrantLock();
    
    /**
     *将指定的元素追加到此列表的末尾。
     *
     * @param e 要添加到此列表的元素
     * @return {@code true} (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
        
            lock.unlock();
        }
    }
    
    /**
     * 用指定的元素替换此列表中指定位置的元素。
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E set(int index, E element) {
        
    	// 获取锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        
            Object[] elements = getArray();
            E oldValue = get(elements, index);
    
            if (oldValue != element) {
        
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
        
                // 并非完全禁止操作；确保volatile的写语义，重刷会主内存
                setArray(elements);
            }
            return oldValue;
        } finally {
        
    		// 释放锁
            lock.unlock();
        }
    }