【Beautiful JUC Part.4】不可不说的“锁”事
【Beautiful JUC Part.4】不可不说的“锁”事
-
Lock接口
-
锁的分类
-
乐观锁和悲观锁
-
可重入锁和非可重入锁,以ReentrantLock为例(重点)
-
公平锁和非公平锁
-
共享锁和排它锁:以ReentrantReadWriteLock读写锁为例(重点)
-
自旋锁和阻塞锁
-
可中断锁:顾名思义,就是可以响应中断的锁
-
锁优化
一、Lock接口
锁是一种工具,用于控制对共享资源的访问。Lock和synchronized,这两个是最常见的锁,它们都可以达到线程安全的目的,打哪是在使用上和功能上又有较大的不同。Lock并不是用来代替synchronized的,而是当使用synchronized不合适或者不足以满足要求的时候,来提供高级功能的。
Lock接口最常见的实现类是ReentrantLock,通常情况下,Lock只允许一个线程来访问这个共享资源。不过有的时候,一些特殊的实现也可以允许并发访问,比如ReadWriteLock里面的ReadLock。
1、为什么synchronized不够用?
效率低:
- 锁的释放情况少、试图获得锁时不能设定超时、不能中断一个正在视图获得锁的线程。
- 不够灵活(读写锁更灵活):加锁和释放的时机单一,每个锁仅有单一的条件(某个对象),可能是不够的。
- 无法知道是否成功获取到锁
2、Lock主要方法介绍
①lock()
- lock()就是最普通的获取锁。如果锁已被其他线程获取,则进行等待。
- Lock不会像synchronized一样在异常时自动释放锁
- 因此最佳实践是,在finally中释放锁,以保证发生异常时锁一定被释放。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 描述:Lock不会像synchronized一样,异常的时候自动释放锁,
* 所以最佳实践是,finally中释放锁,以便保证发生异常的时候锁一定被释放
*/
public class MustUnlock {
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
lock.lock();
try {
//获取本锁保护的资源
System.out.println(Thread.currentThread().getName() + "开始执行任务");
}finally {
lock.unlock();
}
}
}
- lock()方法不能被中断,这会带来很大的隐患:一旦陷入死锁,lock()就会陷入永久等待。
②tryLock()
tryLock()用来尝试获取锁,如果当前锁没有被其他线程占用,则获取成功,则返回true,否则返回false,代表获取锁失败。
- 相比于lock,这样的方法显然功能更强大了,我们可以根据是否能获取到锁来决定后续程序的行为
- 该方法会立即返回,即便在拿不到锁时不会一直在那等。
tryLock(long time, TimeUnit unit):超时就放弃
避免死锁
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 描述:用tryLock来避免死锁
*/
public class TryLockDeadLock implements Runnable{
int flag = 1;
static Lock lock1 = new ReentrantLock();
static Lock lock2 = new ReentrantLock();
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (flag == 1) {
try {
//可能会被中断
if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
try {
System.out.println("线程1获取到了锁1");
Thread.sleep(new Random().nextInt(1000));
if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
try {
System.out.println("线程1获取到了锁2");
System.out.println("线程1成功获取到了两把锁");
break;
} finally {
lock2.unlock();
}
}else {
System.out.println("线程1获取锁2失败,已重试");
}
}finally {
lock1.unlock();
Thread.sleep(new Random().nextInt(1000));
}
}else {
System.out.println("线程1获取锁1失败,已重试");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (flag == 0) {
try {
//可能会被中断
if (lock2.tryLock(3000, TimeUnit.MILLISECONDS)) {
try {
System.out.println("线程2获取到了锁2");
Thread.sleep(new Random().nextInt(1000));
if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
try {
System.out.println("线程2获取到了锁1");
System.out.println("线程2成功获取到了两把锁");
break;
} finally {
lock1.unlock();
}
}else {
System.out.println("线程2获取锁1失败,已重试");
}
}finally {
lock2.unlock();
Thread.sleep(new Random().nextInt(1000));
}
}else {
System.out.println("线程2获取锁2失败,已重试");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
TryLockDeadLock r1 = new TryLockDeadLock();
TryLockDeadLock r2 = new TryLockDeadLock();
r1.flag = 1;
r2.flag = 0;
new Thread(r1).start();
new Thread(r2).start();
}
}
③lockInterruptibly()
相当于tryLock(long time, TimeUnit unit)把超时时间设置为无限。在等待锁的过程中,线程可以被中断。
lock 优先考虑获取锁,待获取锁成功后,才响应中断。
lockInterruptibly 优先考虑响应中断,而不是响应锁的普通获取或重入获取。
ReentrantLock.lockInterruptibly允许在等待时由其它线程调用等待线程的Thread.interrupt方法来中断等待线程的等待而直接返回,这时不用获取锁,而会抛出一个InterruptedException。 ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁,失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程。
线程等锁的时候打断
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockInterruptibly implements Runnable{
private Lock lock = new ReentrantLock();
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "尝试获取锁");
try {
lock.lockInterruptibly();
try {
System.out.println(Thread.currentThread().getName() + "获取到了锁");
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "睡眠期间被中断了");
} finally {
lock.unlock();
System.out.println(Thread.currentThread().getName() + "释放了锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println(Thread.currentThread().getName() + "获得锁期间被中断了");
}
}
public static void main(String[] args) {
LockInterruptibly lockInterruptibly = new LockInterruptibly();
Thread thread0 = new Thread(lockInterruptibly);
Thread thread1 = new Thread(lockInterruptibly);
thread0.start();
thread1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread1.interrupt();
}
}
3、可见性保证
Lock的加解锁和synchronized有同样的内存语义,也就是说,下一个线程加锁后可以看到所有前一个线程解锁前发生的所有操作。(happens-before原则)
二、锁的分类
这些分类并不是互斥的,也就是多个类型可以并存:有可能一个锁,同时属于两种类型
比如ReentrantLock既是互斥锁,又是可重入锁
1、乐观锁和悲观锁
乐观锁——非互斥同步锁
悲观锁——互斥同步锁
思考:为什么会诞生非互斥同步锁?
- 互斥同步锁的劣势
- 阻塞和唤醒带来的性能劣势
- 永久阻塞:如果持有锁的线程被永久阻塞,比如遇到了无限循环、死锁等活跃性问题,那么等待该线程释放锁的那几个悲催的线程,将永远也得不到执行。
- 优先级反转
- 如果优先级低的线程获取到了锁,即便有优先级高的线程来了,也得等待锁释放。
什么是乐观锁和悲观锁?
-
悲观锁:
- 如果我不锁住这个资源,别人就回来争抢,就会造成数据结果错误,所以每次悲观锁为了确保结果的正确性,会在每次获取并修改数据时,把数据锁住,让别人无法访问该数据,这样就可以确保数据内容万无一失。
- 悲观锁的实现就是synchronized和Lock相关类
-
乐观锁:
- 认为自己在处理操作的时候不会有其他线程来干扰,所以并不会锁住被操作对象。
- 在更新的时候,去对比在我修改的期间数据有没有被其他人改变过,如果没有被改变过,就说明真的是只有我自己在操作,那我就正常去修改数据。
- 如果数据和我一开始拿到的不一样了,说明其他人在这段时间内改过数据,那我就不能继续刚才的更新数据过程了,我会选择放弃、报错、重试等策略。
- 乐观锁的实现一般都是利用CAS算法来实现的
- 典型例子就是原子类、并发容器等
使用场景
悲观锁:适合并发写入多的情况,适用于临界区持锁时间比较长的情况,悲观锁可以避免大量的无用自旋等消耗,典型情况:
-
临界区有IO操作
-
临界区代码复杂或者循环量大
-
临界区竞争非常激烈
乐观锁:适合并发写入少,大部分是读取的场景,不加锁能让读取性能大幅提高
2、可重入锁和非可重入锁
以ReentrantLock为例
使用案例:预定电影院座位
import java.util.concurrent.locks.ReentrantLock;
/**
* 描述:演示多线程预定电影院座位
*/
public class CinemaBookSeat {
private static ReentrantLock lock = new ReentrantLock();
private static void bookSeat() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "开始预定座位");
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "完成预定座位");
} catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
new Thread(() -> bookSeat()).start();
new Thread(() -> bookSeat()).start();
new Thread(() -> bookSeat()).start();
new Thread(() -> bookSeat()).start();
}
}
预定座位我们需要一个结束再一个,要不然座位都重复了。
使用案例:打印完整字符串
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 描述: 演示ReentrantLock的基本用法,演示被打断
*/
public class LockDemo {
public static void main(String[] args) {
new LockDemo().init();
}
private void init() {
final Outputer outputer = new Outputer();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("悟空");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
outputer.output("大师兄");
}
}
}).start();
}
static class Outputer {
Lock lock = new ReentrantLock();
//字符串打印方法,一个个字符的打印
public void output(String name) {
int len = name.length();
lock.lock();
try {
for (int i = 0; i < len; i++) {
System.out.print(name.charAt(i));
}
System.out.println("");
} finally {
lock.unlock();
}
}
}
}
打印完整的字符串,需要每个线程加锁,然后释放锁,确保整个字符串都被打印出来。
可重入性质
也叫作递归锁,假设线程再次去申请这个锁的时候,无需提前释放掉这把锁,而是可以直接继续使用手里的这把锁,这就是可重入的意思。比如说汽车摇号,许多人排队摇号,如果轮到一个人拿ipad摇号,摇完号这个人还想给自己其他的车也摇号,这是不行的,必须要重新的排队。这就是不可重入的意思。
好处:避免死锁,提升代码封装性
获取锁次数演示
import java.util.concurrent.locks.ReentrantLock;
public class GetHoldlCount {
private static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
System.out.println(lock.getHoldCount());
lock.lock();
System.out.println(lock.getHoldCount());
lock.lock();
System.out.println(lock.getHoldCount());
lock.lock();
System.out.println(lock.getHoldCount());
lock.unlock();
System.out.println(lock.getHoldCount());
lock.unlock();
System.out.println(lock.getHoldCount());
lock.unlock();
System.out.println(lock.getHoldCount());
}
}
可重入锁源码分析
非可重入所源码分析
可重入所方法介绍
3、公平锁和非公平锁
什么是公平和非公平
公平指的是按照线程请求的顺序,来分配锁;非公平指的是,不完全按照请求的顺序,在一定情况下,可以插队。
注意:非公平也同样不提倡“插队”行为,这里的非公平,指的是“在合适的时机”插队,而不是盲目插队。
那么,什么是合适的时机呢?
比如,线程A持有锁,线程B等待,线程C在运行准备获取锁。当线程A释放锁的时候,线程B的唤醒需要时间,而线程C可以直接运行,这样效率就变高了,直接让C去获取锁,插个队。(唤醒带来的空档期还是比较大的)
ReentrantLock举例
ReentrantLock默认是非公平锁,但是在创建对象时候,参数填写为true,那么这就是个公平锁。
公平锁就是按照先来后到的顺序分配锁。
非公平锁就是插队
代码演示
场景:打印文件,一个线程打印两份文件,采用公平和非公平的方式
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 描述:演示公平和不公平两种情况
*/
public class FairLock {
public static void main(String[] args) {
PrintQueue printQueue = new PrintQueue();
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(new Job(printQueue));
}
for (int i = 0; i < 10; i++) {
threads[i].start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Job implements Runnable{
PrintQueue printQueue;
public Job(PrintQueue printQueue) {
this.printQueue = printQueue;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始打印");
printQueue.printJob(new Object());
System.out.println(Thread.currentThread().getName() + "打印完毕");
}
}
class PrintQueue {
//private Lock queueLock = new ReentrantLock(true);
private Lock queueLock = new ReentrantLock(false);
public void printJob(Object document) {
queueLock.lock();
try {
int duration = new Random().nextInt(10) + 1;
System.out.println(Thread.currentThread().getName() + "正在打印文件一,需要" + duration );
Thread.sleep(duration * 1000);
} catch (InterruptedException e){
e.printStackTrace();
}finally {
queueLock.unlock();
}
queueLock.lock();
try {
int duration = new Random().nextInt(10) + 1;
System.out.println(Thread.currentThread().getName() + "正在打印文件二,需要" + duration );
Thread.sleep(duration * 1000);
} catch (InterruptedException e){
e.printStackTrace();
}finally {
queueLock.unlock();
}
}
}
如上所示,非公平的情况是,线程1打印完以后,再次打印,因为不需要唤醒,而公平的情况是,线程0打印完一次,然后线程1打印,然后线程2打印。
特例
tryLock()会插队
公平和非公平的优缺点
源码分析
4、共享锁和排它锁
什么是共享锁和排它锁
排他锁,又称为独占锁、独享锁
共享锁,又称为读锁,获得共享锁之后,可以查看但无法修改和删除数据,其他线程此时也可以获取到共享锁,也可以查看但无法修改和删除数据
共享锁和排它锁的典型是读写锁ReentrantReadWriteLock,其中读锁是共享锁,写锁是独享锁。
读写锁的作用
在没有读写锁之前,我们假设使用ReentrantLock,那么虽然我们保证了线程安全,但是也浪费了一定的资源:多个读操作同时进行,并没有线程安全问题。
在读的地方使用读锁,在写的地方使用写锁,灵活控制,如果没有写锁的情况下,读是无阻塞的,提高了程序的执行效率。
规则:
- 多个线程只申请读锁,都可以申请到
- 如果有一个线程已经占用了读锁,则此时其他线程如果要申请写锁,则申请写锁的线程会一直等待释放读锁
- 如果有一个线程已经占用了写锁,则此时其他线程如果申请写锁或者读锁,则申请的线程会一直等待释放写锁
- 总结:要么是一个或者多个线程同时有读锁,要么是一个线程有写锁,但是两者不会同时出现(要么多读,要么一写)
读写锁具体用法
电影院买票的案例
案例升级,升级为读写锁
线程1和2都可以读取,到了写入的时候
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CinemaReadWrite {
private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
private static void read() {
readLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了读锁,正在读取");
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "释放读锁");
readLock.unlock();
}
}
private static void write() {
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了写锁,正在写入");
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "释放写锁");
writeLock.unlock();
}
}
public static void main(String[] args) {
new Thread(() -> read(), "Thread1").start();
new Thread(() -> read(), "Thread2").start();
new Thread(() -> write(), "Thread3").start();
new Thread(() -> write(), "Thread4").start();
}
}
读锁插队策略
公平锁:不允许插队
非公平锁:写锁可以随时插队,读锁仅在等待队列头结点不是想获取写锁的线程的时候可以插队
策略一:
策略二:
避免饥饿
锁的升降级
写锁的级别高,读锁的级别低
支持锁的降级,不支持锁的升级,如果升级会造成阻塞
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 描述: 演示ReentrantReadWriteLock可以降级,不能升级
*/
public class Upgrading {
private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(
false);
private static ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
private static ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
private static void readUpgrading() {
readLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了读锁,正在读取");
Thread.sleep(1000);
System.out.println("升级会带来阻塞");
writeLock.lock();
System.out.println(Thread.currentThread().getName() + "获取到了写锁,升级成功");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
System.out.println(Thread.currentThread().getName() + "释放读锁");
readLock.unlock();
}
}
private static void writeDowngrading() {
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "得到了写锁,正在写入");
Thread.sleep(1000);
readLock.lock();
System.out.println("在不释放写锁的情况下,直接获取读锁,成功降级");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
readLock.unlock();
System.out.println(Thread.currentThread().getName() + "释放写锁");
writeLock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
// System.out.println("先演示降级是可以的");
// Thread thread1 = new Thread(() -> writeDowngrading(), "Thread1");
// thread1.start();
// thread1.join();
// System.out.println("------------------");
// System.out.println("演示升级是不行的");
Thread thread2 = new Thread(() -> readUpgrading(), "Thread2");
thread2.start();
}
}
为什么不只是锁的升级?
如果两个读锁线程想要升级为写锁,就必须要求其他读锁线程已经释放,那么两个读锁线程互相等待对方释放,就会陷入死锁。
5、自旋锁和阻塞锁
什么是自旋锁和阻塞锁
原理和源码分析
自己实现一个简单的自旋锁
import java.util.concurrent.atomic.AtomicReference;
public class SpinLock {
private AtomicReference<Thread> sign = new AtomicReference<>();
public void lock() {
Thread current = Thread.currentThread();
while (!sign.compareAndSet(null, current)) {
System.out.println(Thread.currentThread().getName() + "自旋获取失败,再次尝试");
}
}
public void unlock() {
Thread current = Thread.currentThread();
sign.compareAndSet(current, null);
}
public static void main(String[] args) {
SpinLock spinLock = new SpinLock();
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始尝试获取自旋锁");
spinLock.lock();
System.out.println(Thread.currentThread().getName() + "获取到了自旋锁");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
spinLock.unlock();
System.out.println(Thread.currentThread().getName() + "释放了锁");
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
6、可中断锁
三、锁优化
1、自旋锁和自适应锁
JVM不会让傻子自旋锁一直自旋下去,如果时间过长,就转为阻塞锁。
2、锁消除
虚拟机会分辨代码是否是同步的或者私有的,从而消除多余的锁
3、锁粗化
把相邻的可以合并的synchronized代码块合并为一个,避免频繁的加锁释放锁
4、日常使用技巧
- 缩小同步代码块
- 尽量不要锁住方法
- 减少请求锁的次数
- 避免人为制造热点
- 比如hashmap,每次调用size()去获得容量,都会遍历,我们可以人为的设置一个数量count,每次增加或者删除元素,就在count上操作,直接获取就行。
- 锁中尽量不要再包含锁
- 选择合适的锁类型或者合适的工具类