Java 各种各样的锁: 悲观锁 / 乐观锁 / 共享锁 / 公平锁 / 可重入锁 / 自旋锁

关于锁

锁在并发编程之中是必不可少的一部分,且由于 Synchronize 使用起来效率不高,而且缺乏灵活性,所以出现了各式各样的锁。但值得说明的是,如标题所示 “悲观锁、乐观锁、共享锁、公平锁、可重入锁、自旋锁” 大部分并不是代指某个锁的名字这样叫,我认为是指符合这一特性的一类锁。

使用 ReentrantLock.tryLock 解决死锁问题


关于死锁问题,简而言之便是两个线程所被阻塞的缘故是因为缺少对方所持有的锁,因此导致双方都无法正常运行。

而.tryLock 最大的作用就是当在指定时间内(或及时反馈)无法获取到锁的话,会直接返回false,这样我们把要执行的任务放在为true的条件下。当目前任务由于无法继续执行后需任务的时候,则要求此任务结束此次操作,因此该任务所持有的锁将会被释放。

当释放当前拥有的锁之后再进入睡眠,那么另外一个线程借此可能就成功获得该锁,以此死锁便被破除。

    static class t1 implements Runnable {
    @SneakyThrows
    @Override
    public void run() {
        boolean isSuccess = false;
        while (true) {
            if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                try {
                    System.out.println("t1获取到lock1");
                    Thread.sleep(new Random().nextInt(1000));
                    if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
                        try {
                            System.out.println("t1获取到lock2");
                        } finally {
                            lock2.unlock();
                            isSuccess = true;
                        }
                    } else {
                        System.out.println("t1未能获得lock2, 正在重试");
                    }
                } finally {
                    lock1.unlock();
                    Thread.sleep(new Random().nextInt(1000)); //解锁后进行睡眠
                }
            } else {
                System.out.println("t1未能获得lock1, 正在重试");
            }
            if (isSuccess) {
                System.out.println("t1获取到了两把锁");
                break;
            }
        }

    }
}

悲观锁与公平锁

悲观锁

该锁认为,如果自己不去锁住自己要锁的资源的话,那么其他的线程就会来争抢,因此悲观锁为了确保线程安全,会将数据全部锁住使别人无法访问。其代表实现就是Synchronized和Lock相关类。

乐观锁

该锁认为自己在处理数据的时候一般不会有其他线程来争抢资源,因此不会锁住对应的对象,但当乐观锁更新的时候会去对比哪些数据有没有发生改变。如果没有发生改变,那就说明数据只有自己在操作,因此正常执行。但如果发现数据与一开始拿到的不一样的话,那么当前操作会被放弃或报错以及重试等策略。

可重入锁

主要思想为,如果当前要获取的锁已经被锁住了,且获取这把锁的线程是当前线程,那么此时也可以获取锁。

显然,如果该锁不允许可重入性质,那么f2方法将会与f1方法抢夺锁,以致于发生死锁问题。

而这正是 ReentrantLock之所以叫可重入锁的缘故。在其代码之中可以看到,如果当前锁的持有者是当前线程,那么可对当前线程共享这把锁。

reentrant.png

公平和非公平锁

公平锁指的是按照线程的请求顺序来分配锁的所得权,而非公平锁则指不完全按照请求的顺序,在某种情况下可以插队。

那么在什么样的情况下非公平锁会允许某个线程插队呢?

假设线程B执行完毕后去归还锁,之后由A拿到锁,但A从睡眠中被唤醒是存在一定的时间的,假设这时线程C刚好处于活跃状态,那么则这把锁会让线程C插队拿到。

因为即使此时线程C并没有插队,此时线程A也是无法进行任务的,所以优先让线程C获得锁,以提升整体运行效率。

ReentrantLock 公平与非公平设置

显然,ReentrantLock 拥有一个参数表明当前锁是公平锁还是非公平锁,默认为非公平锁。

reentrant_fair.png

公平与非公平输出结果

根据上述概念可知,如果我们将锁设计为公平锁,那么我们得到的任务执行顺序一定是根据顺序而来,反之几乎一定存在插队现象。

代码如下。


public static ReentrantLock lock = new ReentrantLock(false);

public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        new Thread(() -> f()).start();
    }
}
public static void f() {
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + ": 正在执行1");
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + ": 正在执行2");
    } finally {
        lock.unlock();
    }
}

而其后分别构建公平锁以及非公平锁执行,得其结果如下。

显然,在非公平锁的情况下当第一部分代码执行完毕且释放锁后,随后就被后面一部分的代码直接运行(即插队到最前方)。而在公平锁的情况下则是根据队列依次按顺序运行。

fair_result.png

共享锁和排他锁

排他锁,又称为独享锁,当其被使用之时,其他线程无法读亦无法写,这是前述锁的共识,即 ReentrantLock 就是排他锁。

共享锁,便是当它锁住某个资源的时候,资源虽然不允许修改或删除,但允许其他线程去读取操作。共享锁之所以存在,因为有时多个线程去获得资源时可能只是为了去读取资源,这时并不会出现线程安全问题

在Java中的典型是读写锁 ReentrantReadWriteLock, 这把锁下有两把锁以它为载体。其一为读锁,即共享锁。其二为写锁,即排它锁。

public static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public static ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
public static ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

总的来说,当多个线程申请读锁(进行读操作)的时候,是允许它们都持有锁的,显然这也就意味着读写锁适合于读多写少的并发场景。但如果有一个线程已经持有锁且要进行写操作,那么其他线程就无法拿到锁了,哪怕它们只是进行读操作。


public static void read() {
    readLock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "已获得读锁");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        readLock.unlock();
        System.out.println(Thread.currentThread().getName() + "已释放读锁");
    }
}

public static void write() {
    writeLock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "已获得写锁");
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        writeLock.unlock();
        System.out.println(Thread.currentThread().getName() + "已释放写锁");
    }
}

其运行结果为:

read_write_lock.png

另外值得一说的是,读写锁中的读锁在公平锁下一般是不允许插队的。假设此时线程A和B进行读操作,而C和D在队列之中等待,C为写操作,D为读操作。按道理说D完全可以插队,因为它和A以及B是丝毫不干涉的,可以直接同时拥有锁,如果插队可以效率更高。

但如果C只有并不只有一个D,而有成千上万个读,那么线程C将很久不能得到被执行,此时便会出现很大的问题。

那么什么时候是允许插队的呢?即,假设线程A为写锁,其后有读锁B、C、D。当写锁A结束的一瞬间,此时进入了读锁E,那么E就可能插队到B、C、D之前。

自旋锁和阻塞锁

自旋锁一般适用于被锁的代码块内容非常简单,其执行的速度可能小于CP{切换线程状态(即阻塞状态和运行状态的切换)消耗的时间,那么这时被锁住的线程当被阻塞的时候并不会对线程状态进行切换,而是重复进行尝试获取锁(即自旋)。

而阻塞锁则相反,只要无法拿到锁那边直接把线程切换到阻塞状态,等待被唤醒。

降级策略

当线程A持有写锁时,此后有读锁B、C、D,如果想要在线程A不抛弃写锁的同时,使后面的B、C、D执行的话,可以通过再获得一把读锁从而实现降级操作,使后者得以执行。