Java多线程并发之ReentrantLock怎么使用寻技术

本篇内容主要讲解“Java多线程并发之ReentrantLock怎么使用”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java多线程并发之ReentrantLock怎么使用”吧!

ReentrantLock

公平锁和非公平锁

这个类是接口

Lock

的实现类，也是悲观锁的一种，但是它提供了

lock

和

unlock

方法用于主动进行锁的加和拆。在之前使用的

sychronized

关键字是隐式加锁机制，而它是显示加锁，同时，这个类的构造方法提供了公平和非公平的两种机制。

什么是公平和非公平呢？就是多线程对共享资源进行争夺的时候，会出现一个线程或几个线程完全占有共享资源，使得某些线程在长时间处于等待状态。公平就是要等待时间过长的线程先获得锁。

而在

ReentrantLock

类中，提供了公平锁和非公平锁的使用。

在
ReentrantLock
源码中，构造器提供了一个参数入口，

public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync();
}

当fair为true的时候，会创造一个
FairSync
对象给
sync
属性，
FairSync
是继承自
Sync
的类，其中有一个
Lock
方法，而在
ReentrantLock的Lcok
中使用的是
sync
属性的
Lock
方法，故能够保证“公平”。
使用非公平锁就不需要在构造器中传参数。

在使用的时候，需要手动上锁和解锁。

使用公平锁，会将占优势的线程进行限制，恢复挂起的线程，但是这个过程在CPU层面来讲，是存在明显时间差异的，非公平锁的执行效率相对更高，所以一般来说不建议使用公平锁，除非现实业务上需要符合实际需求。

重入锁

ReentrantLock

本身还支持重入的功能。

重入锁（Reentrant Lock）是一种支持重入的独占锁，它允许线程多次获取同一个锁，在释放锁之前必须相应地多次释放锁。重入锁通常由两个操作组成：上锁（lock）和解锁（unlock）。当一个线程获取了重入锁后，可以再次获取该锁而不被阻塞，同时必须通过相同数量的解锁操作来释放锁。

重入锁具有如下特点：

重入性：重入锁允许同一个线程多次获取同一把锁，避免了死锁的发生。
独占性：与公平锁和非公平锁一样，重入锁也是一种独占锁，同一时刻只能有一个线程持有该锁。
可中断性：重入锁支持在等待锁的过程中中断该线程的执行。
条件变量：在使用 java.util.concurrent.locks.Condition 类配合重入锁实现等待/通知机制时，等待状态总是与重入锁相关联的。

重入锁相对于 synchronized 关键字的优势在于，重入锁具有更高的灵活性和扩展性，支持公平锁和非公平锁、可中断锁和可轮询锁等特性，能够更好地满足多线程环境下的并发控制需要。

synchroized

也有重入性。

ReentrantLock lock = new ReentrantLock(true);
public void get(){
    while(true){
        try{
            lock.lock();
            lock.lock();
        }catch(Exception exception){

        }finally{
            lock.unlock();
            lock.unlock();
        }
    }
}

可重入的前提

lock

是同一个对象，而关键字

synchroized

的

Monitor

也是同一个对象充当，才能判定为重入。

public void get(){
    while(true){
        synchronized(this){
            System.out.println("外层");
            synchronized(this){
                System.out.println("内层");
            }
        }
    }
}

那么Java是怎么检测锁的重入和获取锁的次数的呢？在之前说过的

ObjectMobitor

的C++源代码中有

_recursions和_count

来记录锁的重入次数和线程获取锁的次数。这样在Java层面就表示一个锁对象都拥有一个锁计数器
_count
和一个指向持有这个锁的线程的指针
_owner
，只有当前持有锁的线程才能使得计数器+1，其他线程只有等待锁被释放（计数器置0）才能持有并+1。

在源码中，非公平锁的

lock

方法如下：

//ReentrantLock类中：
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
//0的参数为是expect，是期望值，而1是update，是更新值

在执行

comparaAndSetState

方法的时候，它会询问锁的计数器（在底层执行

compareAndSwapInt

的本地方法），并期望数值为0，如果为0返回

true

，然后设置执行线程主是当前线程。如果非0，那么他就会执行

acquire

：

//AbstractQueuedSynchronizer类中：
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
//这里的tryAcquire，需要在其继承的子类中进一步实现对应的功能
//子类可以根据自己的需要重新定义tryAcquire(int arg)的实现方式，从而实现更优秀的锁控制方案：
//而在其子类FairSync中便覆盖了这个方法
protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

将线程放入等待队列。

同时计数器是通过
unlock
来-1，所以
lock和unlock
次数不匹配就会产生死锁，也就是当两个线程调用同一个
ReentrantLock
如果一个线程中的上锁解锁次数不相等，那么计数器没有被清零，当另一个线程请求锁的时候，看到锁计数器不是0，就认为被的线程仍然持有它，所以一直等待它被释放。需要了解底层的可以去看AQS中的
release
方法。

而在

ReentrantLock

中有一个抽象内部类

Sync

，它继承自抽象类

AbstractQueuedSynchronizer

（简称AQS），这个类中有一个内部

Node

类，当有线程等待这把锁的时候，会创建一个等待队列，放置这些处于等待的线程。（AQS实现比较复杂，有兴趣可以看看“竹子爱熊猫”大佬的文章。）

小结

在

ReentrantLock

类中，有内部类三个，

Sync,FairSync,NonfairSync

，他们的关系是

Sync

是后两个的父类，后两个是兄弟类，同时

Sync

继承自AQS类，在AQS中有很多实现公平和非公平、可重入的机制，而具体实现效果的是

Sync,FairSync,NonfairSync

。

疑惑

在下列代码中，为什么在第一个线程的最后加上

.join()

，没有使得线程阻塞，而没有它就会阻塞？

Lock lock = new ReentrantLock();
new CompletableFuture().runAsync(() -> {
    lock.lock();
    try{
        System.out.println(1);
        TimeUnit.SECONDS.sleep(2);
    }catch(Exception e){
    }finally{
}});
//上面加上.join()
new CompletableFuture().runAsync(() -> {
    lock.lock();
    try{
        System.out.println(2);
    }catch(Exception e){
    }finally{
        lock.unlock();
}}).join();

本文地址：https://www.xunjs.com/java/view_19517.html

Tags： ReentrantLoc 多线程 java 并发

相关推荐