转载

Java并发-ReentrantLock

1.简介

可重入锁ReentrantLock自 JDK 1.5 被引入，功能上与synchronized关键字类似，但是功能上比 synchronized 更强大，除可重入之外，ReentrantLock还具有4个特性： 等待可中断、可实现公平锁、可设置超时、以及锁可以绑定多个条件 。在synchronized不能满足的场景下，如公平锁、允许中断、需要设置超时、需要多个条件变量的情况下，需要考虑使用ReentrantLock。

2.用法

ReenTrantLock继承了Lock接口，Lock接口声明有如下方法：

Java并发-ReentrantLock

2.1 可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。

void m1() {

lock.lock();
try {
    // 调用 m2，因为可重入，所以并不会被阻塞
    m2();
} finally {
    lock.unlock()
}

}

void m2() {

lock.lock();
try {
    // do something
} finally {
    lock.unlock()
}

}

注：ReentrantLock的 方法需要置于try-finally块中，需要在finally中释放锁 ，防止因方法异常锁无法释放。

2.2 可中断锁

在等待获取锁过程中可中断。注意是在等待锁过程中才可以中断，如果已经获取了锁，中断就无效 。调用锁的lockInterruptibly方法即可实现可中断锁，当通过这个方法去获取锁时，如果其他线程正在等待获取锁，则这个线程能够响应中断，即 中断线程的等待状态 。也就是说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。示例如下：

public class ReentrantLockTest {

private static int account = 0;
private static ReentrantLock lock = new ReentrantLock();

public static void main (String [] args) {
    
    Thread t1 = new Thread(()->{
            try {
                lock.lockInterruptibly();
                System.out.println("线程t1输出："+account++);
            } catch (InterruptedException e) {
                System.out.println("线程t1被中断了");
            }finally {
                lock.unlock();
            }
        
    },"t1");
    
    Thread t2 = new Thread(()->{
            try {
                lock.lockInterruptibly();
                System.out.println("线程t2输出："+account++);
                // 调用interrupt方法中断线程t1
                t1.interrupt();
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("线程t2被中断了");
            }finally {
                lock.unlock();
            }
    
},"t2");
    t2.start();
    t1.start();
    
}

}

可能的运行结果为：

Java并发-ReentrantLock

注：上面结果只是其中一种可能，在实际运行中可能还有其他结果

通常，中断的使用场景有以下几个：

  1. 点击某个桌面应用中的取消按钮时；
  2. 某个操作超过了一定的执行时间限制需要中止时；
  3. 多个线程做相同的事情，只要一个线程成功其它线程都可以取消时；
  4. 一组线程中的一个或多个出现错误导致整组都无法继续时；
  5. 当一个应用或服务需要停止时。

2.3 公平锁

锁的获取顺序符合请求的绝对时间顺序，即FIFO，先到的线程优先获取锁。

形象的说：

张三、李四、王二去超市购物，只有一个收银台，3人都买完了东西，准备去结账

公平锁：张三发现收银台没有人，立马跑去了收银台结账，李四和王二看见张三在前面，只好乖乖的排队结账了

非公平锁：张三第一个到收银台结账，李四次之，但李四发现张三还没有结完，所以排在了张三后面，此时王二也来了，发现张三结完了，就马上抢着去结账，留下了李四仰天长叹“不公平啊”

public class FairTest {

// 传入true表示 ReentrantLock 的公平锁，false为非公平锁，默认是false非公平锁
private  ReentrantLock lock = new ReentrantLock(true);

public void testFair() {
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() +"获得了锁");
    }finally {
        lock.unlock();
    }     
}

public static void main(String[] args) {
    FairTest fairLock = new FairTest();
    Runnable runnable = () -> {
        System.out.println(Thread.currentThread().getName()+"启动");
        fairLock.testFair();
    };
    Thread[] threadArray = new Thread[5];
    for (int i=0; i<5; i++) {
        threadArray[i] = new Thread(runnable);
        threadArray[i].start();
    }
}

}

可能的运行结果：

Java并发-ReentrantLock

可以看出：锁的获取顺序与线程的请求锁的顺序一致

2.4 设置超时

tryLock() 方法尝试获取一次锁，在成功获得锁后返回true，否则，立即返回false,而且线程可以立即离开去做其他的事情；

tryLock(long timeout, TimeUnit unit) 是一个具有超时参数的尝试申请锁的方法，阻塞时间不会超过给定的值，如果在给定时间内成功获取到锁则返回true，否则阻塞直到超时，然后返回flase。

public class TimeoutTest

{

private ReentrantLock lock = new ReentrantLock();

public void testTryLock() {
    if (lock.tryLock()) {
        try {
            System.out.println(Thread.currentThread().getName() + "获取到锁");
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }           
    }else {
        System.out.println(Thread.currentThread().getName() + "没有获取到锁");
    }
}

public void testTryLockWithTimeout() {
    try {
        if (lock.tryLock(1, TimeUnit.SECONDS)){
            try {
                System.out.println(Thread.currentThread().getName() + "在1s内获取到锁");
                Thread.sleep(1000);
            }finally {
                lock.unlock();
            }                
        }else {
            System.out.println(Thread.currentThread().getName() + "在1s内没有获取到锁");
        }
    }catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() + " was interrupted");
    }      
}

public static void main(String [] args) {
    TimeoutTest timeouttest = new TimeoutTest();
    Runnable runnable = () -> {
        System.out.println(Thread.currentThread().getName()+"启动");
        timeouttest.testTryLock();
        //timeouttest.testTryLockWithTimeout();
    };
    Thread[] threadArray = new Thread[5];
    for (int i=0; i<5; i++) {
        threadArray[i] = new Thread(runnable);
        threadArray[i].start();
    }
}

}

执行testTryLock()可能的运行结果：

Java并发-ReentrantLock

执行testTryLockWithTimeout()可能的运行结果：

Java并发-ReentrantLock

2.5 可绑定多个条件

这是与synchronize最主要的一个区别，synchronize相当于只有一个条件，而ReentrantLock可以绑定多个条件，这也就是在需要多个条件变量的场景下，只能考虑ReentrantLock，比如阻塞队列。

阻塞队列的要求： 当队列中为空时，从队列中获取元素的操作将被阻塞，当队列满时，向队列中添加元素的操作将被阻塞 。

下面代码摘抄自JDK1.8中ArrayBlockingQueue的源码，有所简略，如需了解更多，可阅读ArrayBlockingQueue的源码，或者参考博客《 阻塞队列和ArrayBlockingQueue源码解析（JDK1.8） 》

public class ArrayBlockingQueue<E> {

final Object[] items; //用数组模拟队列
int takeIndex; // 下一次读取或移除的位置
int putIndex; //下一次存放元素的位置
int count; //队列中元素的总数
final ReentrantLock lock; //所有访问的保护锁
private final Condition notEmpty; //队列不空的条件
private final Condition notFull; //队列未满的条件

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}
//入队操作
private void enqueue(E x) {
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    notEmpty.signal();
}
//出队操作
private E dequeue() {
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    notFull.signal();
    return x;
}

//队列满时，向队列中添加元素的操作将被阻塞
public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //使用while循环来判断队列是否已满，防止假唤醒
        while (count == items.length)
            notFull.await();
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

//当队列中为空时，从队列中获取元素的操作将被阻塞
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //使用while循环来判断队列是否已满，防止假唤醒
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private static void checkNotNull(Object v) {
    if (v == null)
        throw new NullPointerException();
}

}

3.原理

原理请参考博客《 Java 重入锁 ReentrantLock 原理分析 》，这篇博客写得非常详细，也很有深度

4.总结

本文从ReentrantLock的4个特性 等待可中断、可实现公平锁、可设置超时、以及锁可以绑定多个条件 入手，总结了ReentrantLock的基本用法，为接下来深入学习ReentrantLock的原理以及在日常开发中熟练使用ReentrantLock打下基础。

原文  https://segmentfault.com/a/1190000020430270
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
Java入门教程 bootstrap3 CSS Apache基础教程 springboot-demo php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 Struts2教程 MongoDB教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 SpringCloud ANTLR教程 Hive教程 java实例教程 Ant教程 Hazelcast教程 Elastic-Job-Lite XStream教程 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 WebService CXF学习 Hadoop教程 solr教程 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Boot集成zipkin快速入门Demo
  2. 2 能用365块大洋去解决的事，千万不要用时间
  3. 3 Spring Boot集成atomikos快速入门Demo
  4. 4 Spring Boot集成fastdfs快速入门Demo
  5. 5 Spring Boot集成Https快速入门Demo
  6. 6 Spring Boot集成easypoi快速入门Demo
  7. 7 Spring Boot集成webflux快速入门Demo
  8. 8 Spring Boot集成Graphql快速入门Demo
  9. 9 Spring Boot API 多版本快速入门Demo
  10. 10 Spring Boot内容协商快速入门Demo
网站信息
  • 文章总数：155,459 篇
  • 文件总数：468,740 个
  • 标签总数：2,264 个
  • 分类总数：90 个
  • 留言数量：2,540 条
  • 在线人数：699 人
  • 运行天数：4,193天
  • 最后更新：2024年04月20日04点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG