Java多线程——Lock独占重入锁与读写锁详解

拼搏现实的明天。 2023-06-07 03:23 17阅读 0赞

## Java多线程——Lock独占重入锁与读写锁详解 ##

### 一、独占式重入锁——ReentrantLock ###

###   1、重入的实现原理 ###

####    ①重入概念： ####

>    **表示能够对共享资源重复加锁，即当前线程再次获取锁时不会被阻塞。**

>   **ReentrantLock究竟是怎样实现可重入性的？**

####    总结一下ReentrantLock实现可重入性：`同一线程再次获取锁时计数自增，释放锁时计数自减直到等于0才释放成功`。 ####

####    ②重入的获取 ####

####     如果该同步状态不为0，表示此时同步状态（锁）已被线程获取，再判断持有同步状态的线程是否是当前线程，如果是，同步状态再次+1并返回true，表示持有线程重入同步块。（类似于monitor） ####

####     执行流程：lock()->acquire()->tryAcquire()->nonfairTryAcquire() ####

final boolean nonfairTryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                // 当前锁未被任何线程占用，当前线程可直接获取该锁，同步状态+1
                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;
            }

####      a）若当前状态==0（设置当前线程持有同步状态的线程）或者当前线程是持有同步状态的线程（同步状态+1），返回true，acquire()的tryAcquire()就不用继续判断了，lock也会直接将持有同步状态线程（当前线程）返回回去 ####

####      b）若当前状态!=0或当前线程不是持有同步状态的线程，说明当前线程没有获取到同步状态，acquire()的tryAcquire()再次获取锁失败，继续接下来的流程（加入同步队列…）即可。 ####

####    ④重入的释放 ####

####      当且仅当同步状态减为0并且持有线程为当前线程时表示锁被正确释放，否则调用setState()将减1后的状态设置为同步状态。若非持有锁线程调用了tryRelease()方法会抛出 IllegalMonitorStateException异常 ####

####     执行流程：unlock()->release()->tryRelease() ####

protected final boolean tryRelease(int releases) {
    			// 同步状态-1
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) {
                	// 只有同步状态==0了，才说明锁可以正常释放
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                // 否则，将同步状态设置为c(同步状态-1)，返回false，锁不能释放
                setState(c);
                return free;
            }

####     tryRelease()会判断当前同步状态-1后的值 ####

####      a）若为0，返回true，说明同步状态为初始状态（锁被完全释放，唤醒其他线程竞争该锁） ####

####      b）若不为0，返回flase，说明同步状态不是初始状态（锁没有被完全释放） ####

>   **可重入锁有什么特点？**

###   2、可重入锁的`特点` ###

####    ①在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功； ####

####    ②由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功。 ####

>   **什么是非公平锁？什么是公平锁？**

###   3、公平锁OR非公平锁 ###

####    ①公平锁与非公平锁的概念 ####

>      **公平锁：锁的获取顺序符合时间上的顺序，即等待时间最长的线程最先获取锁  
>      非公平锁：不是公平锁**

####    ②公平锁与非公平锁的特点 ####

if (!hasQueuedPredecessors() &&
                     compareAndSetState(0, acquires))

####      a）公平锁：获取同步状态并且要是`同步队列中的第⼀个节点`（通过hasQueuedPredecessors()实现） ####

####      b）非公平锁：只要获取了同步状态即成功获取锁(同步队列显得无意义了) ####

>   **非公平锁与公平锁有什么区别？**

####    ③`非公平锁（常用默认）与公平锁的对比` ####

####      公平锁执行acquire()的第一步tryAcquire()尝试获取锁时，需要多加一个判断（hasQueuedPredecessors），判断当前节点在同步队列中是否存在前驱节点，若存在，则该节点绝对不会获取同步状态（后面的就不用执行了），若不存在，说明该节点是同步队列的首节点（等待最久了），才会有继续获取同步状态的可能。（从源头上扼杀获取同步状态的可能），而非公平锁的同步队列中的每一个结点都有可能获取到同步状态。 ####

####      a）公平锁保证了获取到锁的线程一定是等待时间最长的线程，保证了请求资源时间上的绝对顺序，需要频繁的进行上下文切换，性能开销较大，效率较低。 ####

####      b）非公平锁保证系统有更大的吞吐量（效率较高），但是会造成线程“饥饿现象”（有的线程可能永远无法获取到锁） ####

--------------------

### 二、读写锁——ReentrantReadWriteLock ###

>   **究竟什么是读写锁？写程序对应独占锁？而读程序对应共享锁？**

###   1、读写锁的定义 ###

>    **读写锁允许同一时刻被多个读线程访问，但是在写线程访问时，所有的读线程和其他的写线程都会被阻塞。**  
>    **读写锁维护了一个读锁和一个写锁，通过分离读锁和写锁，是并发性大大提高**

####     ①`写线程-独占锁`能够获取到锁的`前提条件`：没有任何读/写线程拿到锁 ####

####     ②`读线程-共享锁`能够获取到锁的`前提条件`：没有写线程拿到锁 ####

>   **为什么前提条件是这样设定？**

####    读写锁要保证写锁的操作对读锁可见，若允许读锁在已被获取的情况下对写锁的获取，name正在运行的其他读线程就无法感知到当前写线程的操作 ####

####     ③当写锁被获取到，阻塞后续（非当前写操作线程）的读写操作。当读锁被获取到，阻塞后续（非当前写操作线程）的写操作，不阻塞读操作。 ####

>   **读锁与无锁到底是不是一回事**

####     PS：`读锁 != 无锁`：当有写线程写的时候，所有读线程都必须全部停止，但如果是无锁的话，其他线程就不会停（无锁的话，不同线程之间互不干扰）。 ####

>   **读写锁是怎么记录读锁和写锁的状态？**

####     ④`同步状态的低16位表示写锁获取次数，高16位表示读锁获取次数`。 ####

>   **写锁的逻辑是怎么实现？**

###   2、写锁-独占锁-WriteLock ###

####     ①写锁获取逻辑 ####

####      a）当读锁已被读线程获取或者写锁已被其他写线程获取，则写线程获取写锁失败； ####

####      b）否则，当前同步状态没有被任何读写线程获取，当前线程获取写锁成功并且支持重入。 ####

####     ②写锁`注意事项` ####

####      a）读写锁确保写锁的操作对读锁可见，不允许读锁在已被获取的情况下对写锁获取（正在运行的其他读线程无法感知到当前写线程的操作） ####

####      b）`只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。` ####

####     ③写锁的释放逻辑同独占式锁的释放（release） ####

>   **读锁的逻辑是怎么实现？**

###   3、读锁-共享式锁-tryAcquireShared() ###

####    当写锁被其他线程获取后，读锁获取失败，其他情况均可成功。 ####

>   **ReentrantReadWriteLock该如何应用？**

####    ReentrantReadWriteLock中有许多操作读锁写锁的方法。 ####

>    getReadLockCount()：返回读锁被获取的次数（不等于线程数，可能一个线程多次获取读锁）  
>    getReadHoldCount()：当前线程获取读锁的次数（保存在ThreadLocal中）  
>    isWriteLocked()：写锁是否被获取  
>    getWriteHoldCount()：写锁被获取的次数

###   4、读写锁实例 ###

>   **`如何线程安全的使用HashMap？`**

public class ReentrantReadWriteLockTest {
        
        // HashMap是线程不安全的，使用读写锁，使得线程安全
        static Map<String,Object> map = new HashMap<>();
        static ReentrantReadWriteLock reentrantReadWriteLock 
                = new ReentrantReadWriteLock();
        static Lock readLock = reentrantReadWriteLock.readLock();
        static Lock writeLock = reentrantReadWriteLock.writeLock();
        
        // 获取一个key对应的value——读锁
        public static final Object get(String key){
            readLock.lock();
            try {
                return map.get(key);
            }finally {
                readLock.unlock();
            }
        }
        
        // 设置key所对应的value，并返回旧的value
        public static final Object put(String key,Object value){
            writeLock.lock();
            try {
                return map.put(key, value);
            }finally {
                writeLock.unlock();
            }
        }
    }

###   5、读写锁相关事项 ###

####     ①读锁和写锁是两个锁，但同一个线程是可以拥有两把锁的。 ####

####     ②若当前同步状态为S ####

>      **写状态获取 S=S+1        写状态释放 S=S-1         低16位（直接加减）  
>      读状态获取 S=S+(1<<16)        读状态释放S=S-(1<<16)     高16位（左移16位）**

####     ③读写锁应用 ####

####     应用于“缓存”的实现（操作系统内存也是个缓存-多读少写） ####

###   6、锁降级 ###

>   **锁降级到底指什么？**

####    锁降级：当前线程把持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。 ####

>   **获取读锁是必要的吗？**

####    `注意`：一定要按照这样的顺序，必须存在获取读锁这步操作，如果先释放了写锁，该写锁被其他线程获取并修改了内容，此时，当前线程就不能感知到数据的更新。而若获取读锁，即便释放写锁后其他线程会被阻塞（当前线程有读锁，写锁不能被调用），直到当前线程释放了读锁，其他线程才会获取到写锁。保证了数据可见性。 ####

####     写锁可以降级为读锁，而读锁不能升级为写锁。 ####