系列文章:Java 核心:语言基础与并发 的第 5 篇。
Lock
Lock对象也可以实现同步,在使用上更加方便。

Java多线程中,可以使用synchronized关键字来实现线程之间同步互斥,但是再jdk1.5以后增加了ReentrantLock类。并且功能更加强大、灵活。
| 锁名称 | 应用 |
|---|---|
| 乐观锁 | CAS |
| 自旋锁 | CAS |
| 悲观锁 | synchronized、vector、hashtable |
| 可重入锁 | synchronized、Reentrantlock、Lock |
| 读写锁 | ReentrantReadWriteLock,CopyOnWriteArrayList、CopyOnWriteArraySet |
| 公平锁 | Reentrantlock(true) |
| 非公平锁 | synchronized、reentrantlock(false) |
| 共享锁 | ReentrantReadWriteLock中读锁 |
| 独占锁 | synchronized、vector、hashtable、ReentrantReadWriteLock中写锁 |
| 重量级锁 | synchronized |
| 互斥锁 | synchronized |
| 同步锁 | synchronized |
| 分段锁 | concurrentHashMap |
| 死锁 | 相互请求对方的资源 |
| 锁粗化 | 锁优化技术 |
| 锁消除 | 锁优化技术 |
| 轻量级锁 | 锁优化技术 |
| 偏向锁 | 锁优化技术 |
AQS-AbstractQueuedSynchronizer
AQS:AbstractQueuedSynchronizer 抽象队列同步器
内部实现了一个FIFO列队来管理锁,线程会首先尝试获取锁,如果失败。则将当前线程以及等待信息包装成一个node节点放入同步列队中柱塞,当有锁的线程释放锁的时候,则会唤醒列队中的等待的线程。

AQS 这里只定义了一个接口,具体资源的获取交由自定义同步器去实现了(通过 state 的 get/set/CAS)之所以没有定义成abstract ,是因为独占模式下只用实现 tryAcquire-tryRelease ,而共享模式下只用实现tryAcquireShared-tryReleaseShared。如果都定义成abstract,那么每个模式也要去实现另一模式下的接口。不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可,至于具体线程等待队列的维护(如获取资源失败入队/唤醒出队等)。
AQS定义类一个
LockSupport
是用来创建锁和其他同步类的基本线程阻塞原语。
CountDownLatch
CounttDownLatch 是 java.util.concurrent(JUC)中的锁,闭锁。利用它可以实现类似计数器的功能。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。
案例
@Test
public void oneTest() {
// 计数器10 state = 10
int total = 10;
CountDownLatch countDownLatch = new CountDownLatch(total);
for (int i = 0; i < total; i++) {
new Thread(() -> {
log.info("running");
countDownLatch.countDown();
}).start();
}
try {
log.info("await");
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
输出
14:22:53.775 [main] INFO cn.z201.java.test.aqs.CountDownLatchTest - await
14:22:53.775 [Thread-7] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-1] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-5] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-8] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-2] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-9] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-4] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-6] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-0] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
14:22:53.775 [Thread-3] INFO cn.z201.java.test.aqs.CountDownLatchTest - running
ReentrantLock
ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。和synchronized也是互斥锁,同时可以实现公平和非公平锁。
构造方法
//默认非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//传入true,可以构建公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
案例
public class LockExample {
private Lock lock = new ReentrantLock();
public void func() {
lock.lock();
try {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
} finally {
lock.unlock(); // 确保释放锁,从而避免发生死锁。
}
}
}
public static void main(String[] args) {
LockExample lockExample = new LockExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> lockExample.func());
executorService.execute(() -> lockExample.func());
}
// 最后输出 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
public class ReentrantLockDemo {
private Lock lock = new ReentrantLock();
public void test(){
// 调用ReentrantLock的lock方法获取锁
lock.lock();
for (int i = 0; i < 3; i++) {
System.out.println("ThreadName " + Thread.currentThread().getName() + " number " + i);
}
// 调用ReentrantLock的lock方法释放锁
lock.unlock();
}
}
public class ReentrantLockThread extends Thread{
private ReentrantLockDemo reentrantLockDemo;
public ReentrantLockThread(ReentrantLockDemo reentrantLockDemo) {
this.reentrantLockDemo = reentrantLockDemo;
}
@Override
public void run() {
reentrantLockDemo.test();
}
}
public class ReentrantLockTests {
public static void main(String[] args) {
ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
ReentrantLockThread reentrantLockThread1 = new ReentrantLockThread(reentrantLockDemo);
ReentrantLockThread reentrantLockThread2 = new ReentrantLockThread(reentrantLockDemo);
ReentrantLockThread reentrantLockThread3 = new ReentrantLockThread(reentrantLockDemo);
ReentrantLockThread reentrantLockThread4 = new ReentrantLockThread(reentrantLockDemo);
reentrantLockThread1.start();
reentrantLockThread2.start();
reentrantLockThread3.start();
reentrantLockThread4.start();
}
}
输出结果
ThreadName Thread-0 number 0
ThreadName Thread-0 number 1
ThreadName Thread-0 number 2
ThreadName Thread-2 number 0
ThreadName Thread-2 number 1
ThreadName Thread-2 number 2
ThreadName Thread-3 number 0
ThreadName Thread-3 number 1
ThreadName Thread-3 number 2
ThreadName Thread-1 number 0
ThreadName Thread-1 number 1
ThreadName Thread-1 number 2
- 当前的线程执行完成之后才能执行其他线程,但是其他线程执行的顺序是随机的。
ReentrantReadWriteLock
ReentrantReadWriteLock锁 实际也是继承了AQS类来实现锁的功能的
案例
@Slf4j
public class ReentrantReadWriteLockTest {
private final Map<String,String> data = new HashMap<>();
/**
* 读、写锁
*/
private final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
/**
* 读锁
*/
private final Lock readLock = reentrantReadWriteLock.readLock();
/**
* 写锁
*/
private final Lock writeLock = reentrantReadWriteLock.writeLock();
@Test
public void test(){
put("a","a");
get("a");
}
public String get(String key){
readLock.lock();
log.info("读锁");
try {
return data.get(key);
}finally {
readLock.unlock();
}
}
public String put(String key ,String value){
writeLock.lock();
log.info("写锁");
try {
return data.put(key,value);
}finally {
writeLock.unlock();
}
}
}
输出
00:25:27.321 [main] INFO cn.z201.java.test.lock.ReentrantReadWriteLockTest - 写锁
00:25:27.325 [main] INFO cn.z201.java.test.lock.ReentrantReadWriteLockTest - 读锁
Semaphore
java.util.concurrent(JUC) ,Semaphore翻译成字面意思为 信号量,Semaphore可以控同时访问的线程个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。
案例
这里防止主线程终止,先睡个10s。
@Test
public void oneTest() throws InterruptedException {
int total = 10;
Semaphore semaphore = new Semaphore(5);
for (int i = 0; i < total; i++) {
new Thread(new SemaphoreRunnable(semaphore)).start();
}
Thread.sleep(10000);
log.info("info");
}
public static class SemaphoreRunnable implements Runnable {
private Semaphore semaphore;
public SemaphoreRunnable(Semaphore semaphore) {
this.semaphore = semaphore;
}
@Override
public void run() {
try {
log.info("{} acquire",Thread.currentThread().getName());
semaphore.acquire();
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//释放信号量
log.info("{} release ",Thread.currentThread().getName());
semaphore.release();
}
}
}
输出
14:10:08.873 [Thread-6] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-6 acquire
14:10:08.874 [Thread-9] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-9 acquire
14:10:08.874 [Thread-5] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-5 acquire
14:10:08.874 [Thread-7] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-7 acquire
14:10:08.874 [Thread-2] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-2 acquire
14:10:08.874 [Thread-4] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-4 acquire
14:10:08.874 [Thread-0] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-0 acquire
14:10:08.874 [Thread-1] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-1 acquire
14:10:08.874 [Thread-8] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-8 acquire
14:10:08.874 [Thread-3] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-3 acquire
14:10:09.884 [Thread-5] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-5 release
14:10:09.884 [Thread-7] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-7 release
14:10:09.884 [Thread-9] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-9 release
14:10:09.884 [Thread-2] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-2 release
14:10:09.884 [Thread-6] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-6 release
14:10:10.885 [Thread-4] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-4 release
14:10:10.885 [Thread-1] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-1 release
14:10:10.885 [Thread-0] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-0 release
14:10:10.886 [Thread-8] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-8 release
14:10:10.886 [Thread-3] INFO cn.z201.java.test.aqs.SemaphoreTest - Thread-3 release
14:10:18.877 [main] INFO cn.z201.java.test.aqs.SemaphoreTest - info
CyclicBarrier
CyclicBarrier 是 java.util.concurrent(JUC)中的锁,栅栏锁。它可以实现让一组线程等待至某个状态之后再全部同时执行。
案例
@Test
public void oneTest() {
int total = 5;
CyclicBarrier cyclicBarrier = new CyclicBarrier(total);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < total; i++) {
executorService.execute(() -> {
log.info("await");
try {
cyclicBarrier.await();
} catch (InterruptedException
| BrokenBarrierException e) {
e.printStackTrace();
}
log.info("running");
});
}
}
输出
15:06:17.233 [pool-1-thread-4] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-3] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-2] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-5] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [pool-1-thread-1] INFO cn.z201.java.test.aqs.CyclicBarrierTest - await
15:06:17.233 [main] INFO cn.z201.java.test.aqs.CyclicBarrierTest - main
15:06:17.239 [pool-1-thread-1] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-2] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-5] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-3] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
15:06:17.239 [pool-1-thread-4] INFO cn.z201.java.test.aqs.CyclicBarrierTest - running
Condition
synchronized 关键字,它配合 Object 的 wait()、notify() 系列方法可以实现等待/通知模式。对于 Lock,通过 Condition 也可以实现等待/通知模式。Condition 是一个接口。Condition 接口的实现类是 Lock(AQS)中的 ConditionObject。Lock 接口中有个 newCondition() 方法,通过这个方法可以获得 Condition 对象(其实就是 ConditionObject )。因此,通过 Lock 对象可以获得 Condition 对象。
Lock lock = new ReentrantLock();
Condition ondition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
CountDownLatch与CyclicBarrier
- CountDownLatch的作用是允许1或N个线程等待其他线程完成执行;而CyclicBarrier则是允许N个线程相互等待
- CountDownLatch的计数器无法被重置;CyclicBarrier的计数器可以被重置后使用,因此它被称为是循环的barrier
CAS Compare-And-Swap
CAS的全称是Compare-And-Swap,它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的,可用于在多线程编程中实现不被打断的数据交换操作,从而避免多线程同时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。该操作通过将内存中的值与指定数据进行比较,当数值一样时将内存中的数据替换为新的值。其原理是利用
sun.misc.Unsafe.java类通过JNI来调用硬件级别的原子操作来实现CAS(即CAS是借助C来调用CPU底层指令实现的)。
CAS = 比较并交换 + 乐观版本锁 + 锁自旋
CAS具备原子性,它是cpu硬件指令实现保证原子性。通过JNI调用Native方法由c++编写的硬件级别指令。JDK中通过Unsafe类执行操作。

- 非阻塞算法
- 非独占锁
ABA问题
CAS 算法实现一个重要前提需要取出内存中某时刻的数据,而在下时刻比较并替换,那么在这个时间差类会导致数据的变化。
- 比如说一个线程 t1 从内存位置 V 中取出 A,这时候另一个线程 t2 也从内存中取出 A,并且t2 进行了一些操作变成了 B,然后 t2 又将 V 位置的数据变成 A,这时候线程 t1 进行 CAS 操作发现内存中仍然是 A,然后 t1 操作成功。此时CAS比较值相等,自旋成功。
- 部分乐观锁的实现是通过版本号(version)的方式来解决 ABA 问题,乐观锁每次在执行数据的修改操作时,都会带上一个版本号,一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1 操作,否则就执行失败。因为每次操作的版本号都会随之增加,所以不会出现 ABA 问题,因为版本号只会增加不会减少。
synchronized和ReentrantLock 的区别
两者都是可重⼊锁
- 两者都是可重⼊锁。“可重⼊锁”概念是:⾃⼰可以再次获取⾃⼰的内部锁。⽐如⼀个线程获得了某个对象的锁,此时这个对象锁还没有释放,当其再次想要获取这个对象的锁的时候还是可以获取的,如果不可锁重⼊的话,就会造成死锁。同⼀个线程每次获取锁,锁的计数器都⾃增1,所以要等到锁的计数器下降为0时才能释放锁。
synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API
- synchronized 是依赖于 JVM 实现的,前⾯我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进⾏了很多优化,但是这些优化都是在虚拟机层⾯实现的,并没有直接暴露给我们。ReentrantLock 是 JDK 层⾯实现的(也就是 API 层⾯,需要 lock() 和 unlock() ⽅法配合try/finally 语句块来完成),所以我们可以通过查看它的源代码,来看它是如何实现的。
synchronized的方式加锁,会让线程在 BLOCKED 状态和 RUNNABLE 状态之间切换,在操作系统上,就会造成用户态和内核态的频繁切换,效率就比较低。
相⽐synchronized,ReentrantLock增加了⼀些⾼级功能
除非需要使用 ReentrantLock 的高级功能,否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制,JVM 原生地支持它,而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题,因为 JVM 会确保锁的释放。
等待可中断
- ReentrantLock提供了⼀种能够中断等待锁的线程的机制,通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待,改为处理其他事情。
实现公平锁
- ReentrantLock可以指定是公平锁还是⾮公平锁。⽽synchronized只能是⾮公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是⾮公平的,可以通过 ReentrantLock类的 ReentrantLock(boolean fair) 构造⽅法来制定是否是公平的。
可实现选择性通知
- ReentrantLock类实现等待/通知机制,需要借助于Condition接⼝与newCondition() ⽅法。Condition是JDK1.5之后才有的,它具有很好的灵活性,⽐如可以实现多路通知功能也就是在⼀个Lock对象中可以创建多个Condition实例(即对象监视器),线程对象可以注册在指定的Condition中,从⽽可以有选择性的进⾏线程通知,在调度线程上更加灵活。 在使⽤notify()/notifyAll()⽅法进⾏通知时,被通知的线程是由 JVM 选择的,⽤ReentrantLock类结合Condition实例可以实现**“选择性通知”** ,这个功能⾮常重要,⽽且是Condition接⼝默认提供的。⽽synchronized关键字就相当于整个Lock对象中只有⼀个Condition实例,所有的线程都注册在它⼀个身上。如果执⾏notifyAll()⽅法的话就会通知所有处于等待状态的线程这样会造成很⼤的效率问题,⽽Condition实例的signalAll()⽅法 只会唤醒注册在该Condition实例中的所有等待线程。
公平锁/非公平锁
公平读写锁比较简单的一种方式是:用队列把获取锁的线程排队,不管是写线程还是读线程都按照先进先出的原则加锁即可,这样读线程仍然可以并发,也不会出现「饥饿」的现象。
- 公平锁的含义是线程需要按照请求的顺序来获得锁;而非公平锁则允许“插队”的情况存在,所谓的“插队”指的是,线程在发送请求的同时该锁的状态恰好变成了可用,那么此线程就可以跳过队列中所有排队的线程直接拥有该锁。
- 而公平锁由于有挂起和恢复所以存在一定的开销,因此性能不如非公平锁,所以 ReentrantLock 和 synchronized 默认都是非公平锁的实现方式。
可重入锁
- 可重入锁又名递归锁,是指在同一个线程,在外层方法获取锁的时候,在进入内层方法会自动获取锁**。**
- 可重入锁的一个好处是可一定程度避免死锁。
共享锁/独占锁
只能被单线程持有的锁叫独占锁,可以被多线程持有的锁叫共享锁。
- 独占锁指的是在任何时候最多只能有一个线程持有该锁,比如 synchronized 就是独占锁,而 ReadWriteLock 读写锁允许同一时间内有多个线程进行读操作,它就属于共享锁。
- 独占锁可以理解为悲观锁,当每次访问资源时都要加上互斥锁,而共享锁可以理解为乐观锁,它放宽了加锁的条件,允许多线程同时访问该资源。
共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后,那么其他线程只能对数据再加共享锁,不能加独占锁。获得共享锁的线程只能读数据,不能修改数据。- 在 JDK 中
ReentrantReadWriteLock就是一种共享锁。
- 在 JDK 中
互斥锁/读写锁
- 上面讲的独享锁/共享锁就是一种广义的说法,互斥锁/读写锁就是具体的实现。
- 互斥锁在Java中的具体实现就是
ReentrantLock - 读写锁在Java中的具体实现就是
ReadWriteLock
- 互斥锁在Java中的具体实现就是
分段锁
- 分段锁其实是一种锁的设计,并不是具体的一种锁,对于
ConcurrentHashMap而言,其并发的实现就是通过分段锁的形式来实现高效的并发操作。
锁升级(无锁|偏向锁|轻量级锁|重量级锁)
无锁状态其实就是上面讲的乐观锁。偏向锁是指一段同步代码一直被一个线程所访问,那么该线程会自动获取锁。降低获取锁的代价。
- 当锁对象第一次被线程获取的时候,虚拟机将会把对象头中的标志位设为“01” (可偏向),即偏向模式。同时使用CAS操作把获取到这个锁的线程的ID记录在对象的Mark Word之中,如果CAS操作成功,持有偏向锁的线程以后每次进入这个锁相关的同步块时,虚拟机都可以不再进行任何同步操作。
- 当有另外一个线程去尝试获取这个锁时,偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态,撤销偏向(Revoke Bias)后恢复到未锁定(标志位为“01”,不可偏向)或 轻量级锁定(标志位为“00”)的状态,后续的同步操作就进入轻量级锁的流程。
进入到轻量级锁说明不止一个线程尝试获取锁,这个阶段会通过自适应自旋CAS方式获取锁。如果获取失败,则进行锁膨胀,进入重量级锁流程,线程阻塞。
重量级锁是通过系统的线程互斥锁来实现的,代价最昂贵
自旋锁
自旋锁是指线程在没有获得锁时不是被直接挂起,而是执行一个忙循环,这个忙循环就是所谓的自旋。- 如果锁被另一个线程占用的时间比较长,即使自旋了之后当前线程还是会被挂起,忙循环就会变成浪费系统资源的操作,反而降低了整体性能。因此自旋锁是不适应锁占用时间长的并发情况的。
互斥锁与自旋锁
- 互斥锁加锁失败后,线程会释放 CPU ,给其他线程;
- 互斥锁是一种「独占锁」,比如当线程 A 加锁成功后,此时互斥锁已经被线程 A 独占了,只要线程 A 没有释放手中的锁,线程 B 加锁就会失败,于是就会释放 CPU 让给其他线程,既然线程 B 释放掉了 CPU,自然线程 B 加锁的代码就会被阻塞。
- 对于互斥锁加锁失败而阻塞的现象,是由操作系统内核实现的。当加锁失败时,内核会将线程置为「睡眠」状态,等到锁被释放后,内核会在合适的时机唤醒线程,当这个线程成功获取到锁后,于是就可以继续执行。
- 互斥锁是一种「独占锁」,比如当线程 A 加锁成功后,此时互斥锁已经被线程 A 独占了,只要线程 A 没有释放手中的锁,线程 B 加锁就会失败,于是就会释放 CPU 让给其他线程,既然线程 B 释放掉了 CPU,自然线程 B 加锁的代码就会被阻塞。
- 自旋锁加锁失败后,线程会忙等待,直到它拿到锁;
- 自旋锁是通过 CPU 提供的
CAS函数(Compare And Swap),在「用户态」完成加锁和解锁操作,不会主动产生线程上下文切换,所以相比互斥锁来说,会快一些,开销也小一些。 - 一般加锁的过程,包含两个步骤:
- 第一步,查看锁的状态,如果锁是空闲的,则执行第二步;
- 第二步,将锁设置为当前线程持有;
- CAS 函数就把这两个步骤合并成一条硬件级指令,形成原子指令,这样就保证了这两个步骤是不可分割的,要么一次性执行完两个步骤,要么两个步骤都不执行。
- 使用自旋锁的时候,当发生多线程竞争锁的情况,加锁失败的线程会「忙等待」,直到它拿到锁。
- 自旋锁是通过 CPU 提供的
锁优化技术(锁粗化|锁消除)
锁粗化就是将多个同步块的数量减少,并将单个同步块的作用范围扩大,本质上就是将多次上锁、解锁的请求合并为一次同步请求。锁消除是指虚拟机编译器在运行时检测到了共享数据没有竞争的锁,从而将这些锁进行消除。
死锁(Deadlock)?如何分析和避免死锁?
- 死锁是指两个以上的线程永远阻塞的情况,这种情况产生至少需要两个以上的线程和两个以上的资源。
- 分析死锁,我们需要查看Java应用程序的线程转储。我们需要找出那些状态为BLOCKED的线程和他们等待的资源。每个资源都有一个唯一的id,用这个id我们可以找出哪些线程已经拥有了它的对象锁。
- 避免嵌套锁,只在需要的地方使用锁和避免无限期等待是避免死锁的通常办法。
案例
@Slf4j
public class DeadLockTest {
public static void main(String[] args) {
Object l1 = new Object();
Object l2 = new Object();
new Thread(()->{
synchronized (l1){
log.info("{} lock 1 success",Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (l2){
log.info("{} lock 2 success",Thread.currentThread().getName());
}
}
}).start();
new Thread(()->{
synchronized (l2){
log.info("{} lock 2 success",Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (l1){
log.info("{} lock 1 success",Thread.currentThread().getName());
}
}
}).start();
}
}
14:53:28.122 [Thread-1] INFO cn.z201.java.test.lock.DeadLockTest - Thread-1 lock 2 success
14:53:28.122 [Thread-0] INFO cn.z201.java.test.lock.DeadLockTest - Thread-0 lock 1 success
如何避免线程死锁
破坏互斥条件 :这个条件我们没有办法破坏,因为我们⽤锁本来就是想让他们互斥的(临界资源需要互斥访问)。
破坏请求与保持条件 :⼀次性申请所有的资源。
破坏不剥夺条件 :占⽤部分资源的线程进⼀步申请其他资源时,如果申请不到,可以主动释放它占有的资源。
破坏循环等待条件 :靠按序申请资源来预防。按某⼀顺序申请资源,释放资源则反序释放。破坏循环等待条件。
Java中常见的线程同步方式
- Object中wait\notify\notifyAll完成对monitor之间的同步。
- synchronized对方法\对象代码块同步。
- volatile关键字修饰字段实现变量的可见性。
- atomic自增自减。
- ThreadLoacal线程局部变量。
- juc包下工具类\LinkedBlockingQueue。
- Thread中join\await方法实现任务顺序执行。
相关规范
- JVM规范
- Java语言规范、Java虚拟机规范、Java内存模型规范。
- JSR规范。
- IETF规范。
小结
AQS 以 state 加等待队列支撑 ReentrantLock、Semaphore 与 CountDownLatch;读写锁分离读写并发,CAS 免阻塞但需处理 ABA,死锁靠固定加锁顺序与超时规避。