并发编程 ReentrantLock 类的实现原理（二十）

旧城等待， 2022-12-28 08:27 86阅读 0赞

今天分析并发编程 ReentrantLock 类的可重入和是非公平实现原理：

***一、锁的可重入***

重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞， 该特性的实现需要解决以下两个问题。

1 ）线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程， 如果是，则再次成功获取。

2 ）锁的最终释放。线程重复  n  次获取了锁，随后在第  n  次释放该锁后，其 他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示 当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于 0  时表示锁已 经成功释放。 nonfairTryAcquire 方法增加了再次获取同步状态的处理逻辑：通过判断当前 线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请 求，则将同步状态值进行增加并返回 true ，表示获取同步状态成功。同步状态表 示锁被一个线程重复获取的次数。如果该锁被获取了 n  次，那么前 (n-1) 次  tryRelease(int releases) 方法必须返回 false，而只有同步状态完全释放了，才能返回  true 。可以看到，该方法将同步状 态是否为 0  作为最终释放的条件，当同步状态为  0  时，将占有线程设置为  null ， 并返回 true ，表示释放成功。

public class ReenterSelfLock implements Lock {
        // 静态内部类，自定义同步器
        private static class Sync extends AbstractQueuedSynchronizer {
    
            // 是否处于占用状态
            protected boolean isHeldExclusively() {
                return getState() > 0;
            }
    
            // 当状态为0的时候获取锁
            public boolean tryAcquire(int acquires) {
                if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }else if(getExclusiveOwnerThread()==Thread.currentThread()){
                    setState(getState()+1);
                    return  true;
                }
                return false;
            }
    
            // 释放锁，将状态设置为0
            protected boolean tryRelease(int releases) {
                if(getExclusiveOwnerThread()!=Thread.currentThread()){
                    throw new IllegalMonitorStateException();
                }
                if (getState() == 0)
                    throw new IllegalMonitorStateException();
    
                setState(getState()-1);
                if(getState()==0){
                    setExclusiveOwnerThread(null);
                }
                return true;
            }
    
            // 返回一个Condition，每个condition都包含了一个condition队列
            Condition newCondition() {
                return new ConditionObject();
            }
        }
    
        // 仅需要将操作代理到Sync上即可
        private final Sync sync = new Sync();
    
        public void lock() {
        	System.out.println(Thread.currentThread().getName()+" ready get lock:"+getState());
            sync.acquire(1);
            System.out.println(Thread.currentThread().getName()+" already got lock:"+getState());
        }
    
        public boolean tryLock() {
            return sync.tryAcquire(1);
        }
    
        public void unlock() {
        	System.out.println(Thread.currentThread().getName()+" ready release lock:"+getState());
            sync.release(1);
            System.out.println(Thread.currentThread().getName()+" already released lock:"+getState());
        }
    
        public Condition newCondition() {
            return sync.newCondition();
        }
    
        public boolean isLocked() {
            return sync.isHeldExclusively();
        }
    
        public boolean hasQueuedThreads() {
            return sync.hasQueuedThreads();
        }
    
        public void lockInterruptibly() throws InterruptedException {
            sync.acquireInterruptibly(1);
        }
    
        public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
            return sync.tryAcquireNanos(1, unit.toNanos(timeout));
        }
    }

测试代码main方法：

public class TestReenterSelfLock {
    
        static final Lock lock = new ReenterSelfLock();
    
        public void reenter(int x){
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+":递归层级:"+x);
                int y = x - 1;
                if (y==0) return;
                else{
                    reenter(y);
                }
            } finally {
                lock.unlock();
            }
    
        }
    
        public void test() {
            class Worker extends Thread {
    			public void run() {
                    System.out.println(Thread.currentThread().getName());
                    SleepTools.second(1);
                    reenter(3);
                }
            }
            // 启动3个子线程
            for (int i = 0; i < 3; i++) {
                Worker w = new Worker();
                w.start();
            }
            // 主线程每隔1秒换行
            for (int i = 0; i < 100; i++) {
            	SleepTools.second(1);
            }
        }
    
        public static void main(String[] args) {
            TestReenterSelfLock testMyLock = new TestReenterSelfLock();
            testMyLock.test();
        }
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

***二、公平和非公平锁***

ReentrantLock  的构造函数中，默认的无参构造函数将会把  Sync  对象创建为 NonfairSync 对象，这是一个“非公平锁”；而另一个构造函数 ReentrantLock(boolean fair)传入参数为  true  时将会把  Sync  对象创建为“公平锁” FairSync。 nonfairTryAcquire(int acquires)方法，对于非公平锁，只要  CAS  设置同步状态 成功，则表示当前线程获取了锁，而公平锁则不同。tryAcquire  方法，该方法与 nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了 hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的 判断，如果该方法返回 true ，则表示有线程比当前线程更早地请求获取锁，因此 需要等待前驱线程获取并释放锁之后才能继续获取锁。

*** ***

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221120/e34ea723e12045918ec91a7ef90de2c7.png