前言
在上章的 多线程二 中，我们学习到为了线程安全，我们需要进行加锁操作，锁这个概念不仅仅只存在于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("比赛结果宣布！"); } }
在代码当中，只有线程全部结束时，才能公布最后的结果
