高并发篇_3 百花齐放的锁和基于CAS手写Lock锁升级过程

梦里梦外; 2022-10-05 04:41 131阅读 0赞

**高并发篇\_3 百花齐放的锁和基于CAS手写Lock锁升级过程**

**田超凡**

**原创博文，仿冒必究，部分素材转载自****每特教育****蚂蚁课堂**

1.  **百花齐放的锁**

**设高并发场景下，同时创建了三个线程分别为T1、T2、T3，且T1、T2、T3三个线程并行执行，那么如何保证线程安全问题，我们可以使用到JUC并发包中的各类锁来满足不同的业务场景需求，JUC并发包中的锁主要包括：**

1.  1.  **无锁No Lock**

**介绍：无锁指的是不适用任何锁，多线程并发执行，不考虑线程安全问题(不会上锁，所有线程永远运行在用户态，根据线程优先级和基于概率分布来分别执行)**

**原理：不使用任何锁**

**适用场景：不需要考虑线程安全，同一时刻可以有多个线程依次执行的场景**

1.  1.  **偏向锁(重入锁) ReentrantLock**

**介绍：偏向锁又叫可重入锁，底层是基于栈数据结构实现的线程抢锁控制。**

**通过重入次数recusion来标记每个线程重入次数。它表示当且仅当只有一个线程运行时，如果需要多次获取锁，则无需频繁获取锁释放锁，只需要获取1次锁(入栈，先入栈先获取锁)和释放1次锁(出栈，FILO)即可(只会进行2次系统调用，一次是获取锁从用户态切换到内核态，一次是释放锁从内核态切换到用户态)，**

**原理：在获取到锁之后如果还需要频繁获取锁则直接复用，而不会频繁进行系统调用**

**适用场景：仅适用于单个线程运行时需要多次获取锁释放锁的场景**

1.  1.  **不可重入锁 Non ReentrantLock**

**介绍：顾名思义，该锁和重入锁是互斥锁，不可重入锁表示锁是不能复用的。**

**原理：如果是单个线程运行，当需要多次获取锁和释放锁时，则按照每个锁的抢锁次序每次都会进行系统调用，也就是说单个线程需要多次获取锁时，需要获取几次，就需要释放几次，对应的就需要进行几次系统调用：**

**设需要抢3个锁，那么获取锁的次数是1，释放锁的次数是1，每个线程总的系统调用次数就是1+1=2次**

**如果是多个线程运行，当需要多次获取锁和释放锁时，每个线程需要获取几次，就需要释放几次，对应的就需要进行几次系统调用：**

**设每个线程需要抢3个锁，那么每个线程获取锁的次数是3，每个线程释放锁的次数是3，每个线程总的系统调用次数就是3\*(3+3) = 18次**

**适用场景：适用于单线程或多线程并发执行时，每次拿到锁每个线程都需要进行系统调用的情况，一般是不建议使用不可重入锁的，因为这样会严重拖慢线程执行效率，因为需要进行太多次的系统调用了，设有n个线程，m个锁，那么不可重入锁的时间复杂度是O(n\*2m)，而可重入锁的时间复杂度仅为O(2n)**

**很明显这种场景下可重入锁(偏向锁)是优越于不可重入锁的，因此在多线程同时需要获取多个锁的情况下，建议使用可重入锁**

1.  1.  **轻量级锁 LightWeight Lock**

**介绍：轻量级锁核心实现是基于CAS算法实现的，轻量级锁只会运行在用户态**

**原理：多个线程同时来获取锁，只有一个线程能CAS成功(CAS(0,1))，其他没有获取到锁的线程不会阻塞而是不断循环重试，直到拿到CAS锁的线程释放锁之后(CAS(1,0))，再继续去竞争CAS锁。CAS轻量级锁运行在用户态，不会在用户态和内核态之间相互进行切换，极大提高了高并发场景下线程执行效率，但是轻量级锁的缺点是CPU资源占用率高且可能会出现ABA问题(3个及以上线程同时抢锁)。**

**适用场景：适用于线程同步代码执行时间比较短，CPU资源较为宽松的场景。因为如果执行时间比较长的话，多线程并发去抢锁，没有抢到锁的线程不断重试的时间就会很长，而重试操作是非常消耗CPU资源的，长时间空转可能会导致CPU飙高的问题，此时可以加上线程休眠来防止CPU飙高**

1.  1.  **重量级锁 HeavyWeight Lock**

**介绍：重量级锁的核心实现是synchronized锁，而synchronized锁底层是JVM虚拟机帮我们封装好的，运行在JVM虚拟机之上，强一致性约束保障同一时刻只有一个线程能够获取到锁执行同步代码，其他没获取到锁的线程一律全部阻塞，直到获取到锁的线程释放锁。如果获取到锁的线程长时间不释放锁，肯能会导致超时进而出现线程死锁问题**

**原理：多个线程同时执行去抢锁，同一时刻只有一个线程能够拿到锁，其他没有拿到锁的线程一律全部阻塞到内核态，直到拿到锁的线程释放锁之后，再切换到内核态去唤醒全部阻塞状态的线程，再将这些线程重新从内核态切换到用户态去竞争锁，然后没有竞争到锁的线程又都会全部切换到内核态阻塞，可以看出重量级锁需要频繁在用户态和内核态之间切换来实现获取锁和释放锁，会导致线程执行效率大打折扣，但是好处是不会占用CPU资源，只是进行频繁的系统调用。**

**适用场景：适用于同步代码执行时间比较长的，或者CPU资源较为紧张的情况，重量级锁不会消耗CPU资源，但是会频繁进行系统调用，大大降低线程在操作系统上的执行效率**

1.  1.  **乐观锁 Optimistic Lock**

**介绍：****乐观锁比较乐观，通过预值或者版本号比较，如果一致则获取到锁，如果不一致则通过不断重试循环控制修改，当前线程不会被阻塞，是乐观的，效率比较高。**

**原理：通过预期值或者版本号进行比较，如果一致获取到锁，如果不一致则不断循环重试，直到获取到锁的线程释放锁后重新竞争**

**适用场景：适用于同步代码执行时间比较短，且CPU资源比较宽松的情况，否则可能会长时间空转导致CPU飙高的问题**

1.  1.  **悲观锁 Pessimistic Lock**

**介绍：悲观锁比较悲观，没有抢到锁的线程直接阻塞，会很悲观地认为没抢到锁我就很失败，我也不想重新再去竞争锁了，直接阻塞在内核态等待其他获取到锁的线程释放锁之后我再去试试。**

**原理：当多个线程对同一行数据实现修改的时候，最后只有一个线程才能修改成功，只要谁能够对获取该到行锁则其他线程时不能够对该数据做任何修改操作，且是阻塞状态。**

**适用场景：foreach update SQL或者事务开启了事务但是没有提交事务。**

1.  1.  **公平锁**

**介绍：多个线程同时去获取锁，按照排队的原则谁先来获取锁谁就先拿到锁，底层是基于队列数据结构实现的，类似食堂排队打饭，先来先排队，后来后排队，已经打了的默认放到队列最后面重新排队，这样可以保证线程有秩序地执行。**

**原理：new ReetrantLock(true)表示创建一个公平锁，底层是采用一个链表来存放没有获取到锁的线程，后面会讲到这个链表是一个双向链表EntrySet，中文翻译是锁池，专门用来存放每次获取锁时没有获取到锁而直接阻塞的线程，当获取到锁的线程释放锁后再唤醒锁池中的下一个线程去抢锁，而不会一次性全部唤醒所有阻塞线程，这样就保证了线程获取锁的公平性，不会出现抢锁一边倒的情况(有的线程能一直抢到锁，有的线程一直抢不到锁)**

**适用场景：适用于需要按顺序获取锁执行的场景，多个线程并行执行去获取锁的时候，按照FIFO的原则，先来的先获取到锁，后来的没有获取到锁的线程加到锁池中，待获取锁的线程释放锁后再唤醒链表中的下一个阻塞的线程来抢锁。**

1.  1.  **非公平锁**

**介绍：非公平锁的典型实现就是synchronized，同一时刻只有一个线程能抢到锁，没有抢到锁的线程立即阻塞，当获取到锁的线程释放锁之后，会一次性唤醒所有阻塞的线程包括当前释放锁的线程一起去重新抢锁。**

**原理：获取到锁的线程释放锁之后，每次都会唤醒锁池里面阻塞的所有线程(包括当前线程)一起去重新获取CAS轻量级锁**

**适用场景：synchronized锁既是重量级锁，又属于非公平锁，所有适用于synchronized锁的场景就适合非公平锁(引用synchronized重量级锁的适用场景：适用于同步代码执行时间比较长，CPU资源较为紧张的场景)**

1.  1.  **独占锁 Exclusive Lock**

**介绍：独占锁，顾名思义，永远只有一个线程能获取到锁。**

**原理：该线程释放锁之后其他线程仍然不会被唤醒，仍然一直阻塞在内核态，该锁被当前线程持有了，就不能再被其他线程持有。**

**适用场景：适用于排他互斥的场景，比如数据库的行锁就是独占锁，同一时刻只能有一个线程能修改和保存行内数据，其他线程都是保存失败。**

1.  1.  **互斥锁 MuteX**

**介绍：互斥锁表示两个线程抢占的锁是互斥的(相反的)，在数据库锁的层面等同于写锁的定义:**

**原理：两个线程抢占的锁在任何时刻都必须是互斥的(相反的)，同一个类型的锁不能被多个线程多次抢占的锁就是互斥锁。**

**数据库写锁：若事务T对数据对象A加上X锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的锁。这保证了其他事务在T释放A上的锁之前不能再读取和修改A。**

**适用场景：比如一个线程抢占到悲观锁，另一个线程只能抢占乐观锁**

1.  1.  **共享锁 Sharing Lock**

**介绍：共享锁也叫做数据库读锁，若事务T对数据对象A加上S锁，则事务T可以读A但不能修改A，其他事务只能再对A加S锁，而不能加X锁，直到T释放A上的S锁。**

**原理：这保证了其他事务可以读A，但在T释放A上的S锁之前不能对A做任何修改。**

**适用场景：事务A对数据对象上锁后，其他事务只能也对该对象上读锁，不能上写锁，直到事务A释放该读锁**

1.  1.  **锁自旋 Lock Spin**

**介绍：CAS的实现机制，锁自旋指的是在用户态不断循环重试，直到拿到锁的线程释放该锁后其他线程就可以有机会直接开始抢占锁，而不会阻塞。**

**原理：基于CAS循环重试原理实现，只会运行在内核态，不会做系统调用**

**适用场景：适用于轻量级锁的适用场景(适用于线程同步代码执行速度比较快，且CPU资源较为宽裕的情况下)**

1.  **Lock****锁升级过程原理**

**原理图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70][]

**简述Lock锁加锁和释放锁步骤：**

**假定现在有三个线程T1(主线程)，T2，T3同时去抢锁(调用lock.lock())**

1.  **抢锁前，三个线程都是无锁状态**
2.  **开始抢锁，偏向锁的实现：先判断T1线程是否已经获取过CAS轻量级锁，如果已经获取过，则记录重入次数递增并直接返回复用之前创建过的锁，不会重复获取锁；如果没有获取过，则进入下一步**
3.  **轻量级锁的实现：T1(释放锁后T2/T3)线程第一个执行，肯定能够拿到CAS锁，将状态从0改成1；其他线程(T2、T3)执行到这一步的时候，肯定就拿不到锁了，此时会不断进行锁自旋重试**
4.  **重量级锁的实现：当没有抢到锁的线程T2、T3锁自旋超过设置的最大锁自旋次数maxRetryNum后，会将没有抢到锁的线程T2、T3阻塞(通过LockSupport.park()实现，从用户态切换到内核态，阻塞在内核态的锁池中等待(将阻塞的线程加入到锁池中，目前是基于LinkedBlockingDeque阻塞队列实现的锁池，所以此时调用offer()将阻塞线程存入到锁池中)，直到抢到锁的T1线程释放锁之后，再全部唤醒锁池中阻塞的线程，重新开始第3步轻量级锁的抢占，并将锁重入次数重新初始化为0，防止递归调用方法出现死锁问题)**

**释放锁的步骤：**

1.  **先判断当前线程是否是之前已经抢占到CAS锁的线程(校验是否是T1线程发起的释放锁请求)，如果是T1，则将重入次数递减**
2.  **轻量级锁释放：T1线程基于CAS将状态从1(已抢到锁的状态)改回为0(未抢占到锁的状态)，然后获取锁池中所有阻塞的线程，调用LockSupport.unpark()方法全部依次唤醒，并将唤醒后的线程从锁池中移除(LinkedBlockingDeque remove())**
3.  **T2****和T3 线程被唤醒，从内核态重新切换回用户态，开始继续重新抢占CAS轻量级锁，重复抢锁的步骤(3)-(4)**

1.  **基于CAS手写Lock锁升级过程**

**package com.tcf.juc.exercise.day04;**

**import java.util.concurrent.LinkedBlockingDeque;**

**import java.util.concurrent.LinkedBlockingQueue;**

**import java.util.concurrent.atomic.AtomicInteger;**

**import java.util.concurrent.locks.LockSupport;**

**/\*\*\***

** \* TODO TCF** **模拟syncronized锁的升级过程**

** \* TODO TCF** **偏向锁(可重入锁) -> 轻量级锁CAS -> CAS自旋 -> 重量级锁**

** \*/**

**public class KidUpdateLock \{**

**    // TODO TCF CAS****轻量级锁原子类**

**    private AtomicInteger casStatus = new AtomicInteger(0);**

**    // TODO TCF** **获取到轻量级锁的线程标记**

**    private Thread casLockedThread;**

**    // TODO TCF** **记录锁重入次数，实现锁的复用(偏向锁)**

**    private Integer reentrantCount = 0;**

**    // TODO TCF** **升级为重量级锁的线程**

**    private LinkedBlockingDeque<Thread> synchronizedThreads = new LinkedBlockingDeque<Thread>();**

**    // TODO TCF** **上锁**

**    public void lock()**

**    \{**

**        // TODO TCF** **偏向锁实现，基于可重入锁原理**

**        if(casLockedThread!=null && casLockedThread == Thread.currentThread())**

**        \{**

**            // TODO TCF** **记录重入次数，直接复用锁，无需重复获取释放轻量级锁**

**            reentrantCount++;**

**            return;**

**        \}**

**        // TODO TCF** **标记每个线程未获取到CAS轻量级锁时的重试次数，超过3次升级为重量级锁**

**        int retryCount = 0;**

**        // TODO TCF CAS****轻量级锁实现**

**        while(true)**

**        \{**

**            // TODO TCF CAS****轻量级锁 -> synchronized重量级锁**

**            if(retryCount>3)**

**            \{**

**                // TODO TCF** **重试3次仍未获取到CAS轻量级锁，则直接升级为重量级锁并记录下来当前线程**

**                synchronizedThreads.offer(Thread.currentThread());**

**                LockSupport.park();**

**            \}**

**            if(casStatus.compareAndSet(0, 1))**

**            \{**

**                // TODO TCF** **记录获取到CAS轻量级锁的线程**

**                casLockedThread = Thread.currentThread();**

**                // TODO TCF** **重入次数累加**

**                reentrantCount++;**

**                return;**

**            \}**

**            // TODO TCF** **重试次数自增**

**            retryCount++;**

**            // TODO TCF** **线程休眠，防止出现CPU飙高**

**            try**

**            \{**

**                Thread.sleep(50);**

**            \}**

**            catch (InterruptedException e)**

**            \{**

**                e.printStackTrace();**

**            \}**

**        \}**

**    \}**

**    // TODO TCF** **释放锁**

**    public void unlock()**

**    \{**

**        // TODO TCF** **偏向锁实现，可重入次数递减，防止递归调用方法**

**        if(casLockedThread!=Thread.currentThread())**

**        \{**

**            try \{**

**                throw new Exception("****非当前线程抢到锁，当前线程无法释放锁");**

**            \} catch (Exception e) \{**

**                e.printStackTrace();**

**            \}**

**        \}**

**        reentrantCount--;**

**        if(reentrantCount==0)**

**        \{**

**            // TODO TCF** **最后一次出栈，释放CAS轻量级锁**

**            while(true)**

**            \{**

**                // TODO TCF CAS****轻量级锁实现**

**                if(casStatus.compareAndSet(1, 0))**

**                \{**

**                    // TODO TCF** **释放重复3次未获取到CAS轻量级锁的线程**

**                    synchronizedThreads.forEach(thread -> \{**

**                        LockSupport.unpark(thread);**

**                        synchronizedThreads.remove(thread);**

**                    \});**

**                    return;**

**                \}**

**                // TODO TCF** **线程休眠，防止空转出现CPU飙高问题**

**                try**

**                \{**

**                    Thread.sleep(50);**

**                \}**

**                catch (InterruptedException e)**

**                \{**

**                    e.printStackTrace();**

**                \}**

**            \}**

**        \}**

**        return;**

**    \}**

**\}**

**测试类：**

**package com.tcf.juc.exercise.day04;**

**/\*\*\***

** \* TODO TCF** **模拟synchronized锁升级过程测试类**

** \*/**

**public class KidUpdateLockTest \{**

**    private static KidUpdateLock kidUpdateLock = new KidUpdateLock();**

**    private static int sum=0;**

**    public static void main(String\[\] args)**

**    \{**

**        Thread t1 = new Thread(new Runnable() \{**

**            @Override**

**            public void run() \{**

**                kidUpdateLock.lock();**

**                for(int i=1;i<=20000;i++)**

**                \{**

**                    sum++;**

**                \}**

**                kidUpdateLock.unlock();**

**            \}**

**        \});**

**        Thread t2 = new Thread(new Runnable() \{**

**            @Override**

**            public void run() \{**

**                kidUpdateLock.lock();**

**                for(int i=1;i<=20000;i++)**

**                \{**

**                    sum++;**

**                \}**

**                kidUpdateLock.unlock();**

**            \}**

**        \});**

**        Thread t3 = new Thread(new Runnable() \{**

**            @Override**

**            public void run() \{**

**                kidUpdateLock.lock();**

**                for(int i=1;i<=20000;i++)**

**                \{**

**                    sum++;**

**                \}**

**                kidUpdateLock.unlock();**

**            \}**

**        \});**

**        t1.start();**

**        t2.start();**

**        t3.start();**

**        try**

**        \{**

**            t1.join();**

**            t2.join();**

**            t3.join();**

**        \}**

**        catch (InterruptedException e)**

**        \{**

**            e.printStackTrace();**

**        \}**

**        System.out.println(sum);**

**    \}**

**    // TODO TCF 1** **偏向锁测试，单线程递归调用实现锁的复用**

**    public static synchronized void a()**

**    \{**

**        kidUpdateLock.lock();**

**        System.out.println("aaa");**

**        b();**

**        kidUpdateLock.unlock();**

**    \}**

**    public static synchronized void b()**

**    \{**

**        kidUpdateLock.lock();**

**        System.out.println("bbb");**

**        c();**

**        kidUpdateLock.unlock();**

**    \}**

**    public static synchronized void c()**

**    \{**

**        kidUpdateLock.lock();**

**        System.out.println("ccc");**

**        kidUpdateLock.unlock();**

**    \}**

**\}**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMwMDU2MzQx_size_16_color_FFFFFF_t_70]: /images/20221005/d2f6ed0d8aae4cefade485d8db3cbe4e.png