前言

一.锁策略

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类

🎁个人主页：tq02的博客_CSDN博客-C语言,Java,Java数据结构领域博主
🎥 本文由 tq02 原创，首发于 CSDN🙉
🎄 本章讲解内容：多线程的策略锁、CAS和JUC

🎥学习专栏： C语言 JavaSE MySQL基础

前言

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

一.锁策略

锁策略一共有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 是一个原子的硬件指令完成的. 这个伪代码只是辅助理解

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的缺点

一次性只能保证一个共享变量的原子性当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子性。
循环会耗时我们可以看到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();
}

用法：

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

与synchronize的区别：

synchronized 是一个关键字, 是 JVM 内部实现的(大概率是基于 C++ 实现). ReentrantLock 是标准库的一个类, 在 JVM 外实现的(基于 Java 实现).
synchronized 使用时不需要手动释放锁. ReentrantLock 使用时需要手动释放. 使用起来更灵活,但是也容易遗漏 unlock.
synchronized 在申请锁失败时, 会死等. ReentrantLock 可以通过 trylock 的方式等待一段时间就
放弃.
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("比赛结果宣布！");
    }
}

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