可重入锁: 又名递归锁,是指在同一个线程在外层方法获取锁的时候,再进入该线程的内层方法会自动获取锁(前提:
锁对象得是同一个对象
),不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁。
类似于家里面的大门,进入之后可以进入厕所、厨房等
“可重入锁”这四个字分开来解释:
- 可:可以。
- 重:再次。
- 入:进入
- 锁:同步锁
- 进入什么:进入同步域(即同步代码块/方法或显式锁锁定的代码)
一句话:一个线程中的多个流程可以获取同一把锁,持有这把同步锁可以再次进入。自己可以获取自己的内部锁
可重入锁种类
隐式锁
隐式锁(即synchronized关键字使用的锁)默认是可重入锁
同步块
package com.aqs;
/**
* @Author: xj0927
* @Description: 可重入锁:可重复可递归调用的锁,在外层使用锁之后,在内层仍然可以使用,并且不发生死锁,这样的锁就叫做可重入锁。
* 在一个synchronized修饰的方法或代码块的内部
* 调用本类的其他synchronized修饰的方法或代码块时,是永远可以得到锁的
* @Date Created in 2021-01-25 10:39
*/
public class ReEnterLock {
//锁对象
static Object objectLockA = new Object();
public static void m1() {
new Thread(() -> {
synchronized (objectLockA) {
System.out.println(Thread.currentThread().getName() + "\t" + "------外层调用");
synchronized (objectLockA) {
System.out.println(Thread.currentThread().getName() + "\t" + "------中层调用");
synchronized (objectLockA) {
System.out.println(Thread.currentThread().getName() + "\t" + "------内层调用");
}
}
}
}, "t1").start();
}
public static void main(String[] args) {
m1();
}
}
结果:
同步方法
package com.aqs;
/**
* @Author: xj0927
* @Description:
* @Date Created in 2021-01-25 10:48
* @Modified By:
*/
public class ReEnterLock2 {
public synchronized void m1() {
System.out.println("=====外层");
m2();
}
public synchronized void m2() {
System.out.println("=====中层");
m3();
}
public synchronized void m3() {
System.out.println("=====内层");
}
public static void main(String[] args) {
new ReEnterLock2().m1();
}
}
Synchronized的重入的实现机理
每个锁对象拥有一个
锁计数器
和一个指向持有该锁的线程
的指针
当执行monitorenter
时,如果目标锁对象的计数器为零,那么说明它没有被其他线程持有,Java虚拟机会将该锁对象
的持有线程设置为当前线程,并且将其计数器加1,否则需要等待,直至持有线程释放该锁
当执行monitorexit
时,Java虚拟机则锁对象的计数器减1。计数器为零代表锁已经被释放
说明:第一个monitorexit
是在方法执行完成时使用,第二个monitorexit
是在发生异常时,能够保证锁的自动释放。
显示锁
显式锁(即Lock)也有ReentrantLock这样的可重入锁。
package com.aqs;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author: xj0927
* @Description:
* @Date Created in 2021-01-25 10:54
* @Modified By:
*/
public class ReEnterLock3 {
static Lock lock = new ReentrantLock();
public static void main(String[] args) {
new Thread(() -> {
lock.lock();
try {
System.out.println("=======外层");
lock.lock();
try {
System.out.println("=======内层");
} finally {
lock.unlock();
}
} finally {
lock.unlock();
}
}, "t1").start();
}
}
结果:
发现,同一个线程可以再次获取、释放同一把锁。
那如果现在加锁释放锁的次数不匹配:加锁两次,释放一次
package com.aqs;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author: xj0927
* @Description:
* @Date Created in 2021-01-25 10:54
* @Modified By:
*/
public class ReEnterLock3 {
static Lock lock = new ReentrantLock();
public static void main(String[] args) {
new Thread(() -> {
//加锁两次
lock.lock();
lock.lock();
try {
System.out.println("=======外层");
lock.lock();
try {
System.out.println("=======内层");
} finally {
lock.unlock();
}
} finally {
//只释放一次
lock.unlock();
}
}, "t1").start();
new Thread(() -> {
lock.lock();
try {
System.out.println("t2 thread----外层调用lock");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t2").start();
}
}
结果:
由于加锁次数和释放次数不一样,第二个线程始终无法获取到锁,导致一直在等待。
正常情况,加锁几次就要解锁几次