JAVA并发之ReentrantLock原理解析

最新推荐文章于 2024-10-16 16:42:50 发布

大哥手下留情

最新推荐文章于 2024-10-16 16:42:50 发布

阅读量893

点赞数

分类专栏： java 开发语言文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/dageliuqing/article/details/127405321

版权

本文详细介绍了JAVA并发中的ReentrantLock，对比了与synchronized的区别，包括可重入性、公平锁、超时机制、可中断特性，并深入探讨了其基于AQS的实现机制和Unsafe的相关使用。

摘要由CSDN通过智能技术生成

在java.util.concurrent.locks包内给我们提供了除了synchronized关键字以外的几个新的锁功能的实现，ReentrantLock就是其中的一个。但是这并不意味着我们可以抛弃synchronized关键字了。

在这些锁实现之前，如果我们想实现锁的功能，只能通过synchronized关键字，例子如下：

private static volatile int value;
public static void main() {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    increaseBySync();
                }
            }
        };
        
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t1.start();
        t2.start();
        
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(value);
}
    
private static synchronized int increaseBySync() {
        return value++;
}

有了ReentrantLock之后，我们可以这样写：

private static volatile int value;
    
private static Lock lock = new ReentrantLock();
    
public static void main(String[] args) {
         testIncreaseWithLock();
}
    
public static void main() {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    for (int i = 0; i < 1000; i++) {
                        value++;
                    }
                } finally {
                    lock.unlock();
                }
            }
        };
        
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t1.start();
        t2.start();
        
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(value);
}

以上两段代码都可以实现value值同步自增1，并且value都能得到正确的值2000。下面我们就来分析下ReentrantLock有哪些功能以及它底层的原理。