编程知识 cdmana.com

Java并发-显式锁篇【可重入锁+读写锁】

作者:汤圆

个人博客:javalover.cc

前言

在前面并发的开篇,我们介绍过内置锁synchronized

这节我们再介绍下显式锁Lock

显式锁包括:可重入锁ReentrantLock、读写锁ReadWriteLock

关系如下所示:

image-20210523174802931

简介

显式锁和内置锁最大的区别就是:显式锁需手动获取锁和释放锁,而内置锁不需要

关于显式锁,本节会分别介绍可它的实现类 - 可重入锁,以及它的相关类 - 读写锁

  • 可重入锁,实现了显式锁,意思就是可重入的显式锁(内置锁也是可重入的)

  • 读写锁,将显式锁分为读写分离,即读读可并行,多个线程同时读不会阻塞(读写,写写还是串行)

下面让我们开始吧

文章如果有问题,欢迎大家批评指正,在此谢过啦

目录

  1. 可重入锁 ReentrantLock
  2. 读写锁 ReadWriteLock
  3. 区别

正文

1.可重入锁 ReentrantLock

我们先来看下它的几个方法:

  • public ReentrantLock();构造函数,默认构造非公平的锁(可插队,如果某个线程获取锁时,刚好锁被释放,那么这个线程就会立马获得锁,而不管队列里的线程是否在等待)

  • public void lock()获取锁,以阻塞的方式(如果其他线程持有锁,则阻塞当前线程,直到锁被释放);

  • public void lockInterruptibly() throws InterruptedException获取锁,以可被中断的方式(如果当前线程被中断,则抛出中断异常);

  • public boolean tryLock(): 尝试获取锁,如果锁被其他线程持有,则立马返回false

  • public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException:尝试获取锁,并设置一个超时时间(如果超过这个时间,还没获取到锁,则返回false)

  • public void unlock(): 释放锁

首先我们先看下它的构造方法,内部实现如下:

public ReentrantLock() {
  sync = new NonfairSync();
}

可以看到,这里创建了一个非公平锁

公平锁:如果获取锁时,被其他线程持有,则将当前线程放入等待队列

非公平锁:如果获取锁时,刚好锁被释放,那么这个线程就会立马获得锁,而不管队列里的线程是否在等待

非公平锁的好处就是,可以减少线程的挂起和唤醒开销

如果某个线程的执行任务所需时间很短,甚至比唤醒队列中的线程所消耗的时间还短,那么非公平锁的优势就很明显

我们可以假设这样一个情景:

  • 线程A的任务执行耗时为10ms
  • 而唤醒队列中的线程B到执行真正去执行线程B的任务耗时为20ms
  • 那么当线程A去获取锁时,刚好锁又被释放,此时线程A抢先获得锁,并执行任务,然后释放锁
  • 当线程A释放锁之后,队列中当线程B才被唤醒正要去获取锁,那么线程B被唤醒的这段时间CPU就没有被浪费,从而提高了程序的性能

这也是为啥默认是非公平锁的原因(一般情况下,非公平锁的性能高于公平锁)

那什么时候应该用公平锁呢?

  • 持有锁的时间较长,即线程的任务执行耗时较长
  • 请求锁的时间间隔较长

因为这种情况下,如果线程插队获取到锁,结果任务还半天执行不完,那么队列中被唤醒的线程醒来发现锁还是被占有的,就会被再次放到队列中(此时并不会提高性能,还有可能降低)

接下来我们看下关键的部分:获取锁

获取锁有多个方法,我们用代码来看下他们之间的区别

  1. 先来看下lock()方法,示例代码如下:
public class ReentrantLockDemo {

    private Lock lock = new ReentrantLock();

    private int i = 0;

    public void add(){
        lock.lock();
        try {
            i++;
        }finally {
            System.out.println(i);
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 100; i++) {
            service.submit(()->{
                demo.add();
            });
        }
    }
}

依次输出1~100,这是因为lock()获取锁时,会以阻塞的方式来获取

  1. 接下来看下 tryLock()方法,代码如下:
public class ReentrantLockDemo {

    private Lock lock = new ReentrantLock();

    private int i = 0;

    public void tryAdd(){
        if(lock.tryLock()){
            try {
                i++;
            }finally {
                System.out.println(i);
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 100; i++) {
            service.submit(()->{
                demo.tryAdd();
            });
        }
    }
}

运行发现,输出永远都少于100,是因为tryLock()如果获取锁失败,会立马返回false,而不是阻塞等待

  1. 最后我们来看下lockInterruptibly()方法,它也是阻塞获取锁,只是比lock()多了个中断异常,即获取锁时,如果线程被中断,则抛出中断异常
public class ReentrantLockDemo {

    private Lock lock = new ReentrantLock();

    private int i = 0;

    public void interruptAdd(){
        try {
            lock.lockInterruptibly();
            i++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo demo = new ReentrantLockDemo();
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 100; i++) {
						// 第10次,立马关闭线程池,停止所有的线程(包括正在执行的和正在等待的)
            if (10 == i){
                service.shutdownNow();
            }
            service.submit(()->{
                demo.interruptAdd();
            });
        }

    }
}

多运行几次,有可能输出如下:

1
2
3
4
5
6
6
6
6
6
java.lang.InterruptedException
	at 
......

这就是因为前面几个都是正常获取到锁并执行了i++,但是后面的几个线程因为被突然停止,所以抛出中断异常

  1. 最后就是释放锁, unlock()

这个就很简单了,上面的代码都有涉及到这个释放锁

不过细心的朋友可能发现了,上面的unlock()都是在finally块中编写的

这是因为在获取锁并执行任务时,有可能抛出异常,此时如果不把unlock()放到finally块中,那么锁不被释放,这在后期是一个很大的隐患(其他线程无法再次获取到这个锁,如果是lock()形式的获取锁,则线程会一直阻塞)

这也是显式锁无法完全替代内置锁的一个原因,有危险

2. 读写锁 ReadWriteLock

读写锁内部就两个方法,分别返回读锁和写锁

读锁属于共享锁,而写锁属于独占锁(前面介绍的可重入锁和内置锁也是独占锁)

读锁允许多个线程同时获取一个锁,因为读不会修改数据,它很适合读多写少的场合

下面我们用代码来看下

先看下读锁,代码如下:

public class ReadWriteLockDemo {

    private int i = 0;
    private Lock readLock;
    private Lock writeLock;


    public ReadWriteLockDemo() {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        this.readLock = lock.readLock();
        this.writeLock = lock.writeLock();
    }

    public void readFun(){
        readLock.lock();
        System.out.println("=== 获取到 读锁 ===");
        try {
            System.out.println(i);
        }finally {
            readLock.unlock();
            System.out.println("=== 释放了 读锁 ===");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReadWriteLockDemo demo = new ReadWriteLockDemo();
        ExecutorService executors = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            executors.submit(()->{
                demo.readFun();
            });
        }
    }
}

多次运行,有可能输出下面的结果:

=== 获取到 读锁 ===
0
=== 获取到 读锁 ===

可以看到,两个线程都获取到了读锁,这就是读锁的优势,多个线程同时读

下面看下写锁,代码如下:(这里用到了ReentrantReadWriteLock类,表示可重入的读写锁)

public class ReadWriteLockDemo {

    private int i = 0;
    private Lock readLock;
    private Lock writeLock;

    public ReadWriteLockDemo() {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        this.readLock = lock.readLock();
        this.writeLock = lock.writeLock();
    }

    public void writeFun(){
        writeLock.lock();
        System.out.println("=== 获取到 写锁 ===");
        try {
            i++;
            System.out.println(i);
        }finally {
            writeLock.unlock();
            System.out.println("=== 释放了 写锁 ===");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReadWriteLockDemo demo = new ReadWriteLockDemo();
        ExecutorService executors = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            executors.submit(()->{
                demo.writeFun();
            });
        }
    }

}

输出如下:可以看到,写锁类似上面的重入锁的lock()方法,阻塞获取写锁

=== 获取到 写锁 ===1=== 释放了 写锁 ====== 获取到 写锁 ===2=== 释放了 写锁 ====== 获取到 写锁 ===3=== 释放了 写锁 ====== 获取到 写锁 ===4=== 释放了 写锁 ====== 获取到 写锁 ===5=== 释放了 写锁 ====== 获取到 写锁 ===6=== 释放了 写锁 ====== 获取到 写锁 ===7=== 释放了 写锁 ====== 获取到 写锁 ===8=== 释放了 写锁 ====== 获取到 写锁 ===9=== 释放了 写锁 ====== 获取到 写锁 ===10=== 释放了 写锁 ===

关于读写锁,需要注意的一点是,读锁和写锁必须基于同一个ReadWriteLock类才有意义

如果读锁和写锁分别是从两个ReadWrite Lock类中获取的,那么读锁和写锁就是完全无关的两个锁,也就不会起到锁的作用(阻止其他线程访问)

这就类似synchronized(a)和synchronized(b),分别锁了两个对象,此时单个线程是可以同时访问这两个锁的

3. 区别

我们用表格来展示吧,细节如下:

锁的特点 内置锁 可重入锁 读写锁
灵活性
公平性 不确定 非公平(默认)+公平 非公平(默认)+公平
定时性 可定时 可定时
中断性 可中断 可中断
互斥性 互斥 互斥 读读共享,其他都互斥

建议优先选择内置锁,只有在内置锁满足不了需求时,再采用显式锁(比如可定时、可中断、公平性)

如果是读多写少的场景(比如配置数据),推荐用读写锁

总结

  1. 可重入锁 ReentrantLock:需显式获取锁和释放锁,切记要在finally块中释放锁
  2. 读写锁 ReadWriteLock:基于显式锁(显式锁有的它都有),多了读写分离,实现了读读共享(多个线程同时读),其他都不共享(读写,写写)
  3. 区别:内置锁不支持手动获取/释放锁、公平性选择、定时、中断,显式锁支持

建议使用锁时,优先考虑内置锁

因为现在内置锁的性能跟显式锁差别不大

而且显式锁因为需要手动释放锁(需在finally块中释放),所以会有忘记释放的风险

如果是读多写少的场合,则推荐用读写锁(成对的读锁和写锁需从同一个读写锁类获取)

参考内容:

  • 《Java并发编程实战》
  • 《实战Java高并发》

后记

最后,祝愿所有人都心想事成,阖家欢乐

版权声明
本文为[汤圆学Java]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/jalon/p/14802079.html

Scroll to Top