Java多线程(3)---锁策略、CAS和JUC

ゝ一纸荒年。 2024-04-20 14:29 87阅读 0赞

**目录**

前言

一.锁策略

1.1乐观锁和悲观锁

⭐ 两者的概念

⭐实现方法

1.2读写锁

⭐概念

⭐实现方法

1.3重量级锁和轻量级锁

1.4自旋锁和挂起等待锁

⭐概念

⭐代码实现

1.5公平锁和非公平锁

1.6可重入锁和不可重入锁

二.CAS

2.1为什么需要CAS

2.2CAS是什么

⭐CAS的介绍

⭐CAS工作原理

2.3CAS存在的问题

2.4CAS的应用

⭐实现原子类

⭐实现自旋锁

2.5CAS的缺点

三.JUC

3.1ReentrantLock类

3.2Semaphore类

3.3CountDownLatch类

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

> ?[个人主页][Link 1]：[tq02的博客\_CSDN博客-C语言,Java,Java数据结构领域博主][tq02_CSDN_-C_Java_Java]  
> ? 本文由 tq02 原创，首发于 CSDN?  
> ? 本章讲解内容：**多****线程的策略锁、CAS和JUC**
> 
> ![55ae5fe7ab844842896947993d3eb222.png][]
> 
> ?学习专栏： [ C语言][C] [JavaSE][] [MySQL基础][MySQL]

## 前言 ##

在上章的[ 多线程二][Link 2] 中，我们学习到为了线程安全，我们需要进行加锁操作，锁这个概念不仅仅只存在于Java当中，锁也分很多种类。CAS在多线程二的讲解中稍微提及过，至于JUC则是指**java.util.concurren**t的常见类。

## 一.锁策略 ##

锁策略一共有10种，在面试的过程当中也是非常重要的，我们需要了解锁策略的每一种。

在面试当中，你的面试官是会询问你的哦，所以为了自己的大钱途，努力学习吧！！！

### 1.1乐观锁和悲观锁 ###

#### ⭐ 两者的概念 ####

*  悲观锁: 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。
 *  乐观锁：假设数据一般情况下不会产生并发冲突，所以在数据进行提交更新的时候，才会正式对数据是否产生并发冲突进行检测，如果发现并发冲突了，则让返回用户错误的信息，让用户决定如何去做。

**抽象表达：**

悲观锁，就相当于学生向老师提问，但是学生认为老师不一定有空，因此先发个信息给老师，老师说有空，则立马去解答，如果没空(被其他线程加锁)，则等待老师有空(解锁)。

乐观锁，学生不认为老师很忙，直接去询问老师，结果2种，老师如果有空则会解答，没空就下次来询问。

#### ⭐**实现方法** ####

> **悲观锁：**使用synchronized关键字来实现，正常的加锁行为。
> 
> **乐观锁：**添加一个版本号，通过在进行数据更新操作时，先读取数据并记录版本号，然后在更新数据时检查版本号是否一致。如果版本号一致，说明没有其他线程修改过数据，可以进行更新；如果版本号不一致，说明其他线程已经修改过数据，更新。

乐观锁Java代码实现：

public class Counter {
        private int count = 0;
        private int version = 0;    //版本号
    
        public void increment() {       
            while (true) {
                 int currentVersion = version;
    
                if (compareAndSet(currentVersion)) {
                    count++;
                    break;
                }
            }
        }
        
        public int getCount() {
            return count;
        }
        
        public synchronized boolean compareAndSet(int expectVersion) {
            if (version == expectVersion) {
                version++;        //版本号相同时，执行一次操作+1
                return true;
            }
            return false;        //版本号不同，则返回false
        }
    
    }

**compareAndSet方法**实现了基于版本号的乐观锁。**increment方法**先读取当前的版本号，然后在一个while循环中不断尝试更新数据，如果**compareAndSet方法**返回true，则表示更新成功，否则需要继续重试。

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

**结论：**悲观锁通过加锁保护共享资源，保证线程安全。乐观锁则通过无锁编程的方式提高并发性能。开发人员需要根据实践场景选择适应的锁。

### 1.2读写锁 ###

#### ⭐概念 ####

多线程之间，数据的读取方之间不会产生线程安全问题，但数据的写入方互相之间以及和读者之间都需要进行互斥。如果两种场景下都用同一个锁，就会产生极大的性能损耗。所以读写锁因此而产生。

> 一个线程对于数据的访问, 主要存在两种操作: 读数据 和 写数据.
> 
>  *  两个线程都只是读一个数据, 此时并没有线程安全问题. 直接并发的读取即可.
>  *  两个线程都要写一个数据, 有线程安全问题.
>  *  一个线程读另外一个线程写, 也有线程安全问题

#### ⭐实现方法 ####

读写锁将读操作和写操作区分对待，而为了实现读写锁，Java标准库提供了**ReentrantReadWriteLock 类**,在该类中又使用了2种类分别实现了读锁和写锁。

*  ReentrantReadWriteLock.ReadLock 类表示一个读锁. 这个对象提供了 lock / unlock 方法进行  
    加锁解锁.
 *  ReentrantReadWriteLock.WriteLock 类表示一个写锁. 这个对象也提供了 lock / unlock 方法进  
    行加锁解锁.

**ReentrantReadWriteLock.ReadLock 类代码实现：**

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class ReadLockDemo {
        private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        private static ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    
        public static void main(String[] args) {
            new Thread(ReadLockDemo::read).start();
            new Thread(ReadLockDemo::read).start();
        }
    
        public static void read() {
            try {
                readLock.lock();    //加锁
                System.out.println(Thread.currentThread().getName() + "获取了读锁");
                // 执行读操作
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();    //解锁
                System.out.println(Thread.currentThread().getName() + "释放了读锁");
            }
        }
    }

**ReentrantReadWriteLock.WriteLock 类代码实现：**

import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    public class MyReadWriteLock {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
        public void writeData() {
            ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
            writeLock.lock();    //加锁
            try {
                // 从文件或数据库中写入数据
                System.out.println(Thread.currentThread().getName() + " is writing data...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                writeLock.unlock();    //解锁
            }
        }
    }

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

**结论**：读加锁和读加锁之间, 不互斥、写加锁和写加锁之间, 互斥、读加锁和写加锁之间, 互斥.

### 1.3重量级锁和轻量级锁 ###

所谓的重量和轻量，就是开销程度大和小。重量级锁：加锁的开销比较大(花的时间多、占用系统资源多).轻量级锁：加锁开销小(花的时间少、占用系统资源少）。

**重量级锁：**交给 OS 管理锁的争抢，释放 CPU 资源，**`ReentrantLock` 类**表示重量级锁

**轻量级锁：**JVM 自己管理锁的争抢（无锁，自旋锁），CPU资源不释放，实现基于CAS。

注：一个悲观锁可能是重量级锁、一个乐观锁可能是轻量锁

### 1.4自旋锁和挂起等待锁 ###

#### ⭐概念 ####

>  **自旋锁**是一种典型的 轻量级锁 的实现方式.  
> 优点: 没有放弃 CPU, 不涉及线程阻塞和调度, 一旦锁被释放, 就能第一时间获取到锁.  
> 缺点: 如果锁被其他线程持有的时间比较久, 那么就会持续的消耗 CPU 资源.

> **挂起等待锁**是一种典型的 重量级锁 的实现方式
> 
> 优点：避免线程的空轮询，确保在锁被释放后立即获取到锁，可以避免不必要的自旋浪费CPU资源。
> 
> 缺点：增加了系统资源消耗和线程的等待时间。

#### ⭐代码实现 ####

**自旋锁的代码实现：**

import java.util.concurrent.atomic.AtomicReference;
    
    public class SpinLock {
    
        private AtomicReference<Thread> lock = new AtomicReference<>();
    
        public void lock() {
            Thread currentThread = Thread.currentThread();
            while (!lock.compareAndSet(null, currentThread)) {
                // 自旋等待
            }
        }
    
        public void unlock() {
            Thread currentThread = Thread.currentThread();
            lock.compareAndSet(currentThread, null);
        }
    }

**挂起等待锁代码实现：**

public class WaitLockExample {
        private final Object lock = new Object();
        private boolean isLocked = false;
    
        public void foo() throws InterruptedException {
            synchronized(lock) {
                while(isLocked) {  //挂起等待中
                    lock.wait();
                }
                // 执行线程的操作
                isLocked = true;
            }
        }
    
        public void bar() {
            synchronized(lock) {
                // 执行线程的操作
                isLocked = false;
                lock.notify();
            }
        }
    }

### 1.5公平锁和非公平锁 ###

**公平锁：**遵循先来后到的原则，例如：线程A、B、C依次来，当A释放锁时，按顺序则下一个加锁的线程为B。

**非公平锁**：不遵守先来后到的原则，例如:线程A、B、C依次来，当A释放锁时，结果下一个加锁的线程为C，而不是B

**注：**操作系统内部的线程调度就可以视为是随机的. 如果不做任何额外的限制, 锁就是非公平锁. 如果要想实现公平锁, 就需要依赖额外的数据结构, 来记录线程们的先后顺序.synchronized 是非公平锁.

### 1.6可重入锁和不可重入锁 ###

**可重入锁**：“可以重新进入的锁”，即允许同一个线程多次获取同一把锁。

情况：递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？不会，那么这个锁就是可重入锁而若是发生阻塞，那么自己阻塞自己，无法解锁，导致了**死锁**。

Java中：以Reentrant开头命名的锁都是可重入锁，而且JDK提供的所有现成的Lock实现类，包括synchronized关键字锁都是可重入的。  
**不可重入锁：**只判断这个锁有没有被锁上，只要被锁上申请锁的线程都会被要求等待。实现简单

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

## 二.CAS ##

### 2.1为什么需要CAS ###

多个线程同时访问锁，那么一些线程将被挂起，当线程恢复执行时，必须等待其它线程执行完他们的时间片以后才能被调度执行，在挂起和恢复执行过程中存在着很大的开销。锁还存在着其它一些缺点，当一个线程正在等待锁时，它不能做任何事。如果一个线程在持有锁的情况下被延迟执行，那么所有需要这个锁的线程都无法执行下去。如果被阻塞的线程优先级高，而持有锁的线程优先级低，将会导致优先级反转。  
 **CAS可以解决这一类弊端，鉴别线程冲突，一旦检测到冲突，就重复当前操作直到没有冲突为止。与锁相比，CAS会使得程序设计比较复杂，但是由于其天生免疫死锁（根本就没有锁，当然就不会有线程一直阻塞了），更为重要的是使用无锁的方式没有锁竞争带来的开销，也没有线程间频繁调度带来的开销，他比基于锁的方式有更优越的性能，所以在目前已经被广泛应用。**

### 2.2CAS是什么 ###

#### ⭐CAS的介绍 ####

CAS机制全称compare and swap，翻译为**比较并交换**，是一种有名的无锁（lock-free）算法。只有一步原子操作，所以非常快。而且CAS避免了请求操作系统来裁定锁的问题，直接在CPU内部就完成了。

**CAS工作伪代码：**真实的 CAS 是一个原子的硬件指令完成的. 这个伪代码只是辅助理解

![93b4e90d24cd462cb83e6428bc5d36ea.png][]

**CAS是由CPU支持的原子操作，其原子性是在硬件层面进行保证的。**

**注：**一个线程的CAS先访问到内存，另一个后访问内存。

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

#### ⭐CAS**工作原理** ####

CAS包含3个值：

*  需要读写的内存位置(V)
 *  原来的值(A)
 *  期待更新的值(B)。

CAS操作逻辑如下：**如果内存位置V的值等于预期的A值，则将该位置更新为新值B，否则不进行任何操作。许多CAS的操作是自旋的：如果操作不成功，会一直重试，直到操作成功为止。**

### 2.3CAS存在的问题 ###

> **ABA问题**  因为CAS会检查旧值有没有变化，因此存在一个问题。比如一个旧值A变为了成B，然后再变成A，刚好在做CAS时检查发现旧值并没有变化依然为A，但是实际上的确发生了变化。**解决方案：**沿袭数据库中常用的**乐观锁方式**，添加一个**版本号**可以解决。原来的变化路径A->B->A就变成了1A->2B->3C。Java 1.5后的atomic包中提供了AtomicStampedReference来解决ABA问题，解决思路就是这样的。

> **自旋时间过长**  使用CAS时非阻塞同步，也就是说不会将线程挂起，会自旋（无非就是一个死循环）进行下一次尝试，如果这里自旋时间过长对性能是很大的消耗。如果JVM能支持处理器提供的pause指令，那么在效率上会有一定的提升。

> **只能保证一个共享变量的原子操作**  当对一个共享变量执行操作时CAS能保证其原子性，如果对多个共享变量进行操作，CAS就不能保证其原子性。
> 
> **解决方案：**利用对象整合多个共享变量，即一个类中的成员变量就是这几个共享变量。然后将这个对象做CAS操作就可以保证其原子性。atomic中提供了AtomicReference来保证引用对象之间的原子性。

### 2.4CAS的应用 ###

#### ⭐实现原子类 ####

Java标准库中提供了 java.util.concurrent.atomic 包, 里面的类都是基于这种方式来实现的.  
典型的就是 AtomicInteger 类. 其中的 getAndIncrement 相当于 i++ 操作

AtomicInteger atomicInteger = new AtomicInteger(0);
    
    atomicInteger.getAndIncrement(); // i++
    
    atomicInteger.incrementAndGet(); //++i
    
    atomicInteger.getAndDecrement(); //i--
    
    atomicInteger.decrementAndGet(); //--i

**代码示例：**

private static AtomicInteger count = new AtomicInteger(0);
    
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                    // count++
                    count.getAndIncrement();             
                }
            });
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                    count.getAndIncrement();
                }
            });
            t1.start();
            t2.start();
    
            System.out.println(count.get());  //输出结果：100000
        }

如上述代码，此时就不会存在相加时，覆盖相同的值了，因此结果为100000.

#### ⭐实现自旋锁 ####

基于 CAS 实现更灵活的锁, 获取到更多的控制权.

自旋锁的代码实现：

public class SpinLock {
    private Thread owner = null;
    public void lock(){
        // 通过 CAS 看当前锁是否被某个线程持有.
        // 如果这个锁已经被别的线程持有, 那么就自旋等待.
        // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程.
        while(!CAS(this.owner, null, Thread.currentThread())){
            }
        }
        public void unlock (){
            this.owner = null;
        }
    }

通过CAS判定出，当前变量的自增过程当中，是否有其他线程穿插进来了。

### 2.5CAS的缺点 ###

1.  一次性只能保证一个共享变量的原子性 当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。
2.  循环会耗时 我们可以看到getAndAddInt方法执行时，如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

在并发冲突概率大的高竞争环境下，如果CAS一直失败，会一直重试，CPU开销较大。针对这个问题的一个思路是引入退出机制，如重试次数超过一定阈值后失败退出。当然，更重要的是避免在高竞争环境下使用乐观锁。

3.存在ABA问题

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

## 三.JUC ##

JUC工具包全名:java.util.concurrent，专门处理线程的工具包，从jdk1.5开始出现。

目的：为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！

而JUC中常见的类有：ReentrantLock ：可重入锁；Semaphore ：信号量；  
ountDownLatch ：计数器； CyclicBarrier ：循环屏障。

### 3.1ReentrantLock类 ###

> ReentrantLock类：可重入互斥锁. 和 synchronized 定位类似, 都是用来实现互斥效果, 保证线程安全.

// ReentrantLock 的构造方法
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

**用法：**

1.  lock(): 加锁, 如果获取不到锁就死等；
2.  trylock(超时时间): 加锁, 如果获取不到锁, 等待一定的时间之后就放弃加锁；
3.  unlock(): 解锁。

**与synchronize的区别：**

1.  synchronized 是一个关键字, 是 JVM 内部实现的(大概率是基于 C++ 实现). ReentrantLock 是标准库的一个类, 在 JVM 外实现的(基于 Java 实现).
2.  synchronized 使用时不需要手动释放锁. ReentrantLock 使用时需要手动释放. 使用起来更灵活,但是也容易遗漏 unlock.
3.  synchronized 在申请锁失败时, 会死等. ReentrantLock 可以通过 trylock 的方式等待一段时间就
4.  放弃.
5.  synchronized 是非公平锁, ReentrantLock 默认是非公平锁. 可以通过构造方法传入一个 true 开启公平锁模式

**那么如何选择哪个锁呢？**

*  锁竞争不激烈的时候, 使用 synchronized, 效率更高, 自动释放更方便.
 *  锁竞争激烈的时候, 使用 ReentrantLock, 搭配 trylock 更灵活控制加锁的行为, 而不是死等.
 *  如果需要使用公平锁, 使用 ReentrantLock.

### 3.2Semaphore类 ###

> Semaphore类：信号量， 用来表示 “可用资源的个数”，本质上就是一个计数器。该类用于控制信号量的个数，构造时传入个数。总数就是控制并发的数量。

抽象解释：五双筷子，A拿了一双，则显示还有4双可用，A放回，则显示还有5双可用。若是5双筷子都被别人拿了，则禁止别人拿取筷子，等待别人放回。

import java.util.concurrent.Semaphore;
    
    public class SemaphoreTest {
    
        public static void main(String[] args) {
            // 创建Semaphore对象，设置许可数为3
            Semaphore semaphore = new Semaphore(3);
    
            // 创建10个线程
            for (int i = 1; i <= 10; i++) {
                MyThread thread = new MyThread(semaphore, i);
                new Thread(thread).start();
            }
        }
    
        static class MyThread implements Runnable {
    
            private Semaphore semaphore;
            private int threadNum;
    
            public MyThread(Semaphore semaphore, int threadNum) {
                this.semaphore = semaphore;
                this.threadNum = threadNum;
            }
    
            @Override
            public void run() {
                try {
                    // 获取许可，若还有许可数，则占用，若无则堵塞
                    semaphore.acquire();
                    System.out.println("线程" + threadNum + "获取到了许可");
                    Thread.sleep(2000); // 模拟线程执行一段耗时的操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 释放许可
                    semaphore.release();
                    System.out.println("线程" + threadNum + "释放了许可");
                }
            }
        }
    
    }

当一个线程调用 acquire() 方法时，计数器就会减一，当计数器为0时，它就会阻塞。当一个线程调用 release() 方法时，它将增加计数器的值，然后唤醒一个被阻塞的线程。

### 3.3CountDownLatch类 ###

**计数器：**同时等待 N 个任务执行结束。例如田径比赛，只有所有人都通过终点，才能公布成绩。

public class CountDownLatchDemo {
        public static void main(String[] args) throws InterruptedException {
            // 创建计算器
            CountDownLatch countDownLatch = new CountDownLatch(5);
            // 创建线程池
            ExecutorService service = Executors.newFixedThreadPool(5);
            // 创建新线程执行任务
            for (int i = 1; i <= 5; i++) {
                service.submit(() -> {
                    Thread currThread = Thread.currentThread();
                    System.out.println(currThread.getName() + "开始起跑");
                    int runTime = new Random().nextInt(5) + 1;
                    try {
                        TimeUnit.SECONDS.sleep(runTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(currThread.getName() + "到达终点，用时：" + runTime);
                    countDownLatch.countDown();  //在 CountDownLatch 内部的计数器同时自减.
                });
            }
     
            countDownLatch.await();  //阻塞等待所有任务执行完毕
            System.out.println("比赛结果宣布！");
        }
    }

在代码当中，只有线程全部结束时，才能公布最后的结果

##  ##

[Link 1]: https://so.csdn.net/so/search?q=%E4%B8%AA%E4%BA%BA%E4%B8%BB%E9%A1%B5&spm=1001.2101.3001.7020
[tq02_CSDN_-C_Java_Java]: https://blog.csdn.net/m0_74097410?spm=1010.2135.3001.5343
[55ae5fe7ab844842896947993d3eb222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1193f5fb193c4123af8cf1ddc0939770.png
[C]: http://t.csdn.cn/3A5e9
[JavaSE]: http://t.csdn.cn/TBH4P
[MySQL]: http://t.csdn.cn/2FRvG
[Link 2]: http://t.csdn.cn/nwKf2
[93b4e90d24cd462cb83e6428bc5d36ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e1959bc5b80449ca9145a80ac8f84792.png