ReentrantLock原理详解

蔚落 2023-01-07 07:08 218阅读 0赞

### ReentrantLock简介： ###

ReentrantLock是可重入的独占锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞而被放入该锁的AQS阻塞队列里面。

ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

从类图可以看到，ReentrantLock最终还是使用AQS来实现的，并且根据参数来决定其内部是一个公平还是非公平锁，默认是非公平锁。

### 获取锁： ###

**1、void lock()方法**

当一个线程调用该方法时，说明该线程希望获取该锁。如果锁当前没有被其他线程占用并且当前线程之前没有获取该锁，则当前线程会获取到该锁，然后设置当前锁的拥有者为当前线程，并设置AQS的状态值为1，然后直接返回。如果当前线程之前已经获取过该锁，则这次只是简单地把AQS的状态值加1后返回。如果该锁已经被其他线程持有，则调用该方法的线程会被放入AQS队列后阻塞挂起。

**2、void lockInterruptibly()方法**

该方法与lock()方法类似，它的不同在于，它对中断进行响应，就是当前线程在调用该方法时，如果其他线程调用了当前线程的interrupt()方法，则当前线程会抛出InterruptedException异常，然后返回。

**3、boolean tryLock()方法**

尝试获取锁，如果当前该锁没有被其他线程持有，则当前线程获取该锁并返回true，否则返回false。值得注意的是，该方法不会引起当前线程阻塞。

**4、boolean tryLock(long timeout, TimeUnit unit)方法**

尝试获取锁，与tryLock()的不同之处在于，它设置了超时时间，如果超时时间到，没有获取到该锁则返回false。

### 释放锁： ###

1、void unlock()方法

尝试释放锁，如果当前线程持有该锁，则调用该方法会让线程对该线程持有的AQS状态值减1，如果减去1后当前状态值为0，则当前线程会释放该锁，否则仅仅减1而已。如果当前线程没有持有该锁而调用了该方法则会抛出IllegalMonitorStateException异常。

### 应用： ###

**使用ReentrantLock实现一个简单的线程安全的list：**

public static class ReentrantLockList {
        // 线程不安全的list
        private ArrayList<String> array = new ArrayList<String>();
        // 独占锁
        private volatile ReentrantLock lock = new ReentrantLock();
        
        // 添加元素
        public void add(String e) {
            lock.lock();
            try {
                array.add(e);
            }finally {
                lock.unlock();
            }
        }
    
        // 删除元素
        public void remove(String e) {
            lock.lock();
            try {
                array.remove(e);
            }finally {
                lock.unlock();
            }
        }
    
        // 获取数据
        public String get(int index) {
            lock.lock();
            try {
                return array.get(index);
            }finally {
                lock.unlock();
            }
        }
    }

如上代码通过在操作array元素前进行加锁保证同一时间只有一个线程可以对array数组进行修改，但是也只能有一个线程对array元素进行访问。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1][]

如上图所示，加入线程Thread1、Thread2、Thread3同时尝试获取独占锁ReentrantLock，假设Thread1获取到了，则Thread2和Thread3就会被转换为Node节点并被放入ReentrantLock对应的AQS阻塞队列，而后被阻塞挂起。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 2][]

假设Thread1获取锁后调用了对应的锁创建的条件变量1，那么Thread1就会释放获取到的锁，然后当前线程就会被转换为Node节点插入条件变量1的条件队列。由于Thread1释放了锁，所以阻塞到AQS队列里面的Thread2和Thread3就有机会获取到该锁，假如使用的是公平策略，那么这时候Thread2会获取到该锁，从而从AQS队列里面移除Thread2对应的Node节点。

### 总结： ###

ReentrantLock的底层是使用AQS实现的可重入独占锁，在这里AQS状态值为0表示当前锁空闲，为大于等于1的值则说明该锁已经被占用。该锁内部有公平与非公平实现，默认情况下是非公平的实现。另外，由于该锁是独占锁，所以某时只有一个线程可以获取该锁。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221119/122b675bac2d4eeeb1c8a2e12cb5bb38.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 1]: /images/20221119/a5e499a8043b45c197e6a472212c99bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70 2]: /images/20221119/bebe2f9994254bc3a7af9965a16d3e13.png