Java并发编程系列---可重入锁和读写锁的实现原理、源码分析

最新推荐文章于 2021-09-21 16:48:32 发布

忘不掉就记着吧

最新推荐文章于 2021-09-21 16:48:32 发布

阅读量1k

点赞数 1

分类专栏：多线程与高并发文章标签： reentrantLock 重入锁读写锁 java 多线程

本文链接：https://blog.csdn.net/weiwei_six/article/details/104266044

版权

本文深入探讨Java并发编程中的重入锁与读写锁。首先介绍了重入锁的概念、作用及ReentrantLock如何实现重进入，包括nonfairTryAcquire和tryRelease方法。接着，讨论了公平锁与非公平锁的区别。在读写锁部分，阐述了读写锁的特性、作用，以及ReentrantReadWriteLock的实现，包括读写状态设计、锁的获取与释放以及锁降级。通过对ReentrantReadWriteLock的详细分析，揭示了其在提高并发性和简化编程上的优势。

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

一、重入锁

1.1 什么是重入锁

重入锁ReentrantLock，就是支持重进入的锁，它表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁的还支持获取锁时的公平和非公平性选择。

1.2 重入锁有什么用

例子：之前AQS的一个自己实现的锁

package com.example.demo.thread;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author : pengweiwei
 * @date : 2020/2/9 6:51 下午
 */
public class Mutex implements Lock {
   

    // 静态内部类，自定义同步器
    private static class Sync extends AbstractQueuedSynchronizer {
   
        // 是否处于占用状态
        protected boolean isHeldExclusively() {
   
            return getState() == 1;
        }

        // 当状态为0的时候获取锁
        public boolean tryAcquire(int acquires) {
   
            //如果状态从 0 变成1 成功 则表示获取到了锁
            if (compareAndSetState(0, 1)) {
   
                //设置当前线程拥有独占访问权
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 释放锁，将状态设置为0
        protected boolean tryRelease(int releases) {
   
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // 返回一个Condition，每个condition都包含了一个condition队列
        Condition newCondition() {
   
            return new ConditionObject();
        }
    }

    private final Sync sync = new Sync();

    @Override
    public void lock() {
   
        sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
   
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
   
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
   
        return sync.tryAcquireNanos(1,unit.toNanos(time));
    }

    @Override
    public void unlock() {
   
        sync.release(