Java并发编程之 ReentrantLock 介绍

╰+攻爆jí腚メ 2022-10-22 12:58 131阅读 0赞

# ReentrantLock #

### 文章目录 ###

*  ReentrantLock
 *   *  一、活跃性问题
     *   *  1. 死锁
         *  2. 活锁
         *  3. 饥饿
     *  二、ReentrantLock
     *   *  1. 基本介绍
         *  2. 可重入
         *  3. 可打断
         *  4. 锁超时
         *  5. 公平锁
         *  6. 条件变量

## 一、活跃性问题 ##

活跃性：代码是有限的，但由于某种原因代码一直执行不完

活跃性有三种情况：死锁、活锁、饥饿

活跃性相关的一系列问题都可以用 ReentrantLock 进行解决

### 1. 死锁 ###

双方都持有对方需要的锁，且不解锁，都在等待对方释放锁，导致二者谁都无法进行下去

@Slf4j(topic = "c.MyTest")
    public class MyTest { 
        static String s1 = new String("s1");
        static String s2 = new String("s2");
        public static void main(String[] args) throws InterruptedException { 
            new Thread(() -> { 
                synchronized (s1){ 
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    log.debug("t1线程尝试获取s2锁");
                    synchronized (s2){ 
    
                    }
                }
            }, "t1").start();
    
            new Thread(() -> { 
                synchronized (s2){ 
                    try { 
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    log.debug("t2线程尝试获取s1锁");
                    synchronized (s1){ 
    
                    }
                }
            }, "t2").start();
        }
    }
    //两条线程陷入阻塞，都无法执行下去

### 2. 活锁 ###

两个线程互相改变对方的结束条件，最后谁也无法结束

@Slf4j(topic = "c.TestLiveLock")
    public class TestLiveLock { 
        static volatile int count = 10;
        static final Object lock = new Object();
    
        public static void main(String[] args) { 
            new Thread(() -> { 
                // 期望减到 0 退出循环
                while (count > 0) { 
                    sleep(0.2);
                    count--;
                    log.debug("count: {}", count);
                }
            }, "t1").start();
            
            new Thread(() -> { 
                // 期望超过 20 退出循环
                while (count < 20) { 
                    sleep(0.2);
                    count++;
                    log.debug("count: {}", count);
                }
            }, "t2").start();
        }
    }

**活锁和死锁的区别：**

活锁：两个线程没有阻塞，一直在向下运行

死锁：两个线程出现了阻塞的现象

### 3. 饥饿 ###

一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束

## 二、ReentrantLock ##

### 1. 基本介绍 ###

*  ReentrantLock即可重入锁
 *  相对于 synchronized 它具备如下特点：
    
     *  可打断，如果获取锁失败则进入阻塞队列，可以调用 interrupt 方法打断，离开阻塞队列，抛出异常
        
         *  这种方式以可避免死锁（被动）
     *  可以设置锁超时，规定时间内争抢不到锁，则放弃争抢锁，去执行其他的逻辑（主动），可避免死锁
     *  可以设置为公平锁，采用先来先服务调度算法，避免出现饥饿现象
     *  支持多个条件变量（waitset），即对于不满足条件的线程可以放到不同的集合中等待
 *  与 synchronized 一样，都支持可重入

基本语法

//首先创建ReentrantLock对象
    
    // 加锁（获取锁）
    reentrantLock.lock();
    
    try { 
     	// 临界区，需要上锁的代码
    } finally { 
     	// 释放锁
     	reentrantLock.unlock();
    }
    
    //加锁的代码放在try-catch结构中，效果一样

### 2. 可重入 ###

可重入是指同一个线程如果首次获得一把锁，那么它就成为这把锁的拥有者，因此有权利再次直接获取这把锁

如果是不可重入锁，那么同一个线程第二次获得锁时，自己也会被锁挡住

@Slf4j(topic = "c.MyTest")
    public class MyTest { 
        public static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) { 
            lock.lock(); // 当前线程首次获得了这把锁
            try { 
                log.debug("进入main方法");
                m1(); // 未解锁就调用了当前线程的m1方法
            } finally { 
                lock.unlock();
            }
        }
    
        private static void m1() { 
            lock.lock(); // m1方法执行锁重入
            try { 
                log.debug("进入m1方法");
                m2(); // 未解锁就调用了当前线程的m2方法
            } finally { 
                lock.unlock();
            }
        }
    
        private static void m2() { 
            lock.lock(); // m2方法执行锁重入
            try { 
                log.debug("进入m2方法");
            } finally { 
                lock.unlock();
            }
        }
    }

运行结果：

![20210317151052284.png][]

可以发现，ReentrantLock是支持锁重入的，加锁之后没有释放锁就可以直接被本线程的其他方法获取到锁

### 3. 可打断 ###

调用`lock.lockInterruptibly();`表示此锁可打断

@Slf4j(topic = "c.MyTest")
    public class MyTest { 
        public static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) throws InterruptedException { 
            Thread t1 = new Thread(() -> { 
                try { 
                    log.debug("t1线程尝试获取锁");
                    
                    // 如果没有锁竞争那么此方法就会获取lock对象锁
                    // 如果有竞争就会进入阻塞队列，可以被其他线程调用interrupt方法打断
                    // 从而离开阻塞队列，抛出InterruptException异常
    
                    lock.lockInterruptibly();
    
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                    log.debug("没有获取锁，离开阻塞队列");
                    return;
                }
                try { 
                    log.debug("t1线程获取到了锁");
                } finally { 
                    lock.unlock();
                }
            }, "t1");
    
            lock.lock(); // 主线程先获取锁
    
            t1.start(); // 启动t1线程
    
            Thread.sleep(1000);
            log.debug("主线程打断t1");
            t1.interrupt();
        }
    }

运行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70][]

如果将 lockInterruptibly 修改为 lock 方法，则即使主线程调用 interrupt 方法，t1仍然处于阻塞状态

### 4. 锁超时 ###

调用`lock.tryLock(long, TimeUnit);`表示此锁支持锁超时，long时间内尝试获得锁失败则放弃获得锁，返回值为 boolean，表示是否获取到锁

@Slf4j(topic = "c.Test22")
    public class Test22 { 
        private static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) throws InterruptedException { 
            Thread t1 = new Thread(() -> { 
                log.debug("t1尝试获得锁");
                try { 
                    if (! lock.tryLock(2, TimeUnit.SECONDS)) { 
                        log.debug("t1获取不到锁，不等了，继续向下执行");
                        return;
                    }
                    //tryLock方法也有可打断的特性
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                    log.debug("t1获取不到锁，不等了，继续向下执行");
                    return;
                }
                try { 
                    log.debug("t1获得到锁");
                } finally { 
                    lock.unlock();
                }
            }, "t1");
    
            lock.lock(); //主线程先获取锁
            log.debug("主线程获得到锁");
            t1.start();
            Thread.sleep(1000);
            log.debug("主线程释放了锁");
            lock.unlock();
        }
    }

运行结果：

![2021031715111724.png][]

如果tryLock方法为空参，则获取不到锁立马返回

### 5. 公平锁 ###

*  synchronized锁中，在 entrylist 中等待的线程在竞争锁时不是按照先到先得来获取锁的，所以说synchronized锁是不公平的
 *  ReentrantLock锁默认是不公平的，可以通过构造器 `ReentrantLock lock = new ReentrantLock(true);` 实现公平锁
 *  公平锁一般没有必要，会降低并发度

### 6. 条件变量 ###

*  synchronized 中也有条件变量，即 waitSet 队列，当条件不满足时进入 waitSet 等待
 *  ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的
    
     *  synchronized 是那些不满足条件的线程都在一间休息室等待
     *  ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室，唤醒时也是按照不同的休息室来唤醒，并不是像synchronized一样将所有休息室的线程都唤醒
 *  `await()`将线程放入休息室，`signal()`将线程从休息室唤醒
 *  使用步骤
    
        import java.util.concurrent.locks.Condition;
        import java.util.concurrent.locks.ReentrantLock;
        
        @Slf4j(topic = "c.MyTest")
        public class MyTest { 
            
            static ReentrantLock lock = new ReentrantLock();
        
            public static void main(String[] args) throws InterruptedException { 
        
                //1. 创建条件变量（休息室）
                Condition condition1 = lock.newCondition();
                Condition condition2 = lock.newCondition();
        
                //2. 先获取锁
                lock.lock();
        
                //3. 调用await方法会释放锁，将当前线程进入休息室1等待
                condition1.await();
        
                //4. 调用signal / signalAll方法唤醒休息室中的线程
                condition1.signal();
        
                //被唤醒的线程去重新竞争锁，竞争成功，则从await之后继续执行
            }
        }

[20210317151052284.png]: /images/20221022/65086fb807e743e3ac8fb0bf23a9395f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70]: /images/20221022/1498ce7dd8d2472897d14a9c2f276b5c.png
[2021031715111724.png]: /images/20221022/678bc42348864bd19cae3ffe2580650c.png