可重入锁和不可重入锁概念和区别

本文主要是介绍可重入锁和不可重入锁概念和区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

可重入锁就是一个类的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来计数重入次数，避免了频繁的持有释放操作，这样既提升了效率，又避免了死锁。