本文主要是介绍可重入锁和不可重入锁概念和区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
可重入锁就是一个类的A、B两个方法，A、B都有获得统一把锁，当A方法调用时，获得锁，在A方法的锁还没有被释放时，调用B方法时，B方法也获得该锁。
这种情景，可以是不同的线程分别调用这个两个方法。也可是同一个线程，A方法中调用B方法，这个线程调用A方法。
不可重入锁就是一个类的A、B两个方法，A、B都有获得统一把锁，当A方法调用时，获得锁，在A方法的锁还没有被释放时，调用B方法时，B方法也获得不了该锁，必须等A方法释放掉这个锁。
https://blog.csdn.net/h2604396739/article/details/81255028
https://blog.csdn.net/rickiyeat/article/details/78314451
在java 中，synchronized和java.util.concurrent.locks.ReentrantLock是可重入锁。
当一个线程获得当前实例的锁lock，并且进入了方法A，该线程在方法A没有释放该锁的时候，是否可以再次进入使用该锁的方法B？
不可重入锁：在方法A释放锁之前，不可以再次进入方法B
可重入锁：在方法A释放该锁之前可以再次进入方法B
下面是其中一个例子
public class LockClient {
// Lock lock = new Lock();
ReinnerLock lock = new ReinnerLock();
void read() throws InterruptedException{
lock.lock();
System.out.println("read");
read1();
lock.unLock();
}
void read1() throws InterruptedException{
lock.lock();
System.out.println("read1");
lock.unLock();
}
public static void main(String[] args) {
try {
//此时执行结果为 read和read1都能打印出来
//如果使用的锁是 Lock则报IllegalMonitorStateException
new LockClient().read();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
不可重入锁的实现：
public class Lock {
private boolean isLocked = false;
public void lock() throws InterruptedException{
while(isLocked){//如果已经被获取锁，则当前线程只能等待
wait();
}
isLocked = true;
}
public void unLock(){
isLocked = false;
}
}
可重入锁的实例：
public class ReinnerLock {
private boolean isLocked = false;
Thread thread = null;//当前的线程
public void lock() throws InterruptedException{
Thread currentThread = Thread.currentThread();
while(isLocked && thread!=currentThread){
wait();
}
isLocked = true;
thread = currentThread;
}
public void unLock(){
isLocked = false;
}
}
广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁，下面是一个用synchronized实现的例子：
public class ReentrantTest implements Runnable {
public synchronized void get() {
System.out.println(Thread.currentThread().getName());
set();
}
public synchronized void set() {
System.out.println(Thread.currentThread().getName());
}
public void run() {
get();
}
public static void main(String[] args) {
ReentrantTest rt = new ReentrantTest();
for(;;){
new Thread(rt).start();
}
}
}
整个过程没有发生死锁的情况，截取一部分输出结果如下：
Thread-8492
Thread-8492
Thread-8494
Thread-8494
Thread-8495
Thread-8495
Thread-8493
Thread-8493
set()和get()同时输出了线程名称，表明即使递归使用synchronized也没有发生死锁，证明其是可重入的。
不可重入锁
不可重入锁，与可重入锁相反，不可递归调用，递归调用就发生死锁。看到一个经典的讲解，使用自旋锁来模拟一个不可重入锁，代码如下：
import java.util.concurrent.atomic.AtomicReference;
public class UnreentrantLock {
private AtomicReference<Thread> owner = new AtomicReference<Thread>();
public void lock() {
Thread current = Thread.currentThread();
//这句是很经典的“自旋”语法，AtomicInteger中也有
for (;;) {
if (!owner.compareAndSet(null, current)) {
return;
}
}
}
public void unlock() {
Thread current = Thread.currentThread();
owner.compareAndSet(current, null);
}
}
代码也比较简单，使用原子引用来存放线程，同一线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁就不是可重入的，而实际上同一个线程不必每次都去释放锁再来获取锁，这样的调度切换是很耗资源的。稍微改一下，把它变成一个可重入锁：
import java.util.concurrent.atomic.AtomicReference;
public class UnreentrantLock {
private AtomicReference<Thread> owner = new AtomicReference<Thread>();
private int state = 0;
public void lock() {
Thread current = Thread.currentThread();
if (current == owner.get()) {
state++;
return;
}
//这句是很经典的“自旋”式语法，AtomicInteger中也有
for (;;) {
if (!owner.compareAndSet(null, current)) {
return;
}
}
}
public void unlock() {
Thread current = Thread.currentThread();
if (current == owner.get()) {
if (state != 0) {
state--;
} else {
owner.compareAndSet(current, null);
}
}
}
}
在执行每次操作之前，判断当前锁持有者是否是当前对象，采用state计数，不用每次去释放锁。
ReentrantLock中可重入锁实现
这里看非公平锁的锁获取方法：
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//就是这里
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
在AQS中维护了一个private volatile int state来计数重入次数，避免了频繁的持有释放操作，这样既提升了效率，又避免了死锁。
这篇关于可重入锁和不可重入锁概念和区别的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
