面试高频——JUC并发工具包快速上手（超详细总结）

目录

一、什么是JUC二、基本知识2.1、进程和线程2.2、Java默认有两个进程2.3、Java能够开启线程吗？2.4、并发和并行2.5、线程的状态2.6、wait和sleep的区别2.7、什么是可重入锁2.8、synchronized买票案例回顾

三、Lock锁3.1、简介3.2、买票问题重现3.3、和Synchronized的区别

四、生产者消费者问题(Lock版)4.1、Synchronized实现虚假唤醒问题

4.2、Lock实现Condition精准通知唤醒

五、8个案例彻底理解锁的对象六、安全集合类6.1、CopyOnWriteArrayListArrayList不安全引入CopyOnWriteArrayList

6.2、CopyOnWriteArraySetHashSet不安全引入CopyOnWriteArraySet

6.3、ConcurrentHashMapHashMap不安全引入ConcurrentHashMap

七、Callable7.1、同Runnable的区别7.2、怎么实现

八、三大常用辅助类8.1、CountDownLatch8.2、CyclicBarrier8.3、Semaphore

九、读写锁十、阻塞队列10.1、关系图10.2、ArrayBlockingQueue四组API抛出异常(add、remove、element)不跑出异常(offer、poll、pick)等待阻塞(put、take)限时等待()

10.3、SynchronousQueue

十一、线程池11.1、创建线程池三大方法newSingleThreadExecutornewFixedThreadPoolnewCachedThreadPool

11.2、七大参数11.3、四种拒绝策略11.4、最大线程数怎么定义？CPU密集型IO密集型

十二、四大函数式接口什么是函数式接口12.1、Function12.2、Predicate12.3、Consumer12.4、Supplier

十三、Stream流式计算13.1、什么是Stream流式计算13.2、案例测试

十四、ForkJoin14.1、什么是ForkJoin14.2、ForkJoin的特点14.3、案例：计算求和任务

十五、异步回调十六、理解JMM&Volatile16.1、请你谈谈对Volatile的理解16.2、什么是JMM16.3、Volatile特点1. 保证可见性2. 不保证原子性3. 禁止指令重排

十七、彻底玩转单例模式17.1、饿汉式17.2、懒汉式17.3、双重检测锁式17.4、静态内部类式反射破坏单例模式17.5、枚举单例

十八、深入理解CAS18.1、什么是CAS18.2、ABA问题

十九、各种锁的理解19.1、乐观锁/悲观锁悲观锁(Pessimistic Lock)乐观锁(Optimistic Locking)

19.2、公平/非公平锁19.3、可重入锁19.4、自旋锁19.5、死锁什么是死锁？死锁问题排查

参考：

狂神说Java_JUC并发编程最新版通俗易懂什么是乐观锁什么是悲观锁

一、什么是JUC

JUC就是java.util.concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。

二、基本知识

2.1、进程和线程

进程是程序的一次执行过程，包含进程控制块、程序段、数据三部分

1️⃣ 动态性

动态性是进程最基本的特征，表现为：由创建而产生，由调度而执行，得不到资源而暂停执行，由撤销而消亡；有一定的生命周期程序只是一组有序的指令集合

2️⃣ 并发性

引入进程的目的就是和其他进程能并发执行程序不能并发执行

3️⃣ 独立性

进程实体是一个能独立运行的基本单位，是系统中独立获得资源和独立调度的基本单位程序不能作为一个独立的单位进行运行

2.2、Java默认有两个进程

Main和GC

2.3、Java能够开启线程吗？

不行，Java是通过native本地方法调底层C++写的方法，Java无法直接操作硬件

2.4、并发和并行

并发：多个事件在同一时间间隔内发生（cpu一核，模拟出来多条线程快速交替运行）并行：多个事件在同一时刻发生（cpu多核，多个线程可以同时执行）

查看cpu的核数

2.5、线程的状态

NEW尚未启动的线程处于此状态RUNNABLE在Java虚拟机中执行的线程处于此状态BLOCKED被阻塞等待监视器锁定的线程处于此状态（IO操作，wait，juc锁定）WAITING正在等待另一个线程执行特定动作的线程处于此状态（sleep，join)TIMED_WAITING正在等待另一个线程执行动作达到指定等待时间的线程处于此状态（sleep，join）TERMINATED已退出的线程处于此状态。

2.6、wait和sleep的区别

sleep不释放锁，wait释放锁来自不同的类：sleep()函数在Thread类中，wait()函数属于Object类使用范围不同：sleep可以在任何地方使用，wait只能使用在同步代码块中

2.7、什么是可重入锁

可重入，就是可以重复获取相同的锁而不会出现死锁；synchronized和ReentrantLock都是可重入的

// 演示可重入锁是什么意思，可重入，就是可以重复获取相同的锁

// synchronized和ReentrantLock都是可重入的

// 可重入降低了编程复杂性

public class WhatReentrant {

public static void main(String[] args) {

new Thread(new Runnable() {

@Override

public void run() {

synchronized (this) {

System.out.println("第1次获取锁，这个锁是：" + this);

int index = 1;

while (true) {

synchronized (this) {

System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);

}

if (index == 10) {

break;

}

}

}

}

}).start();

}

}

import java.util.Random;

import java.util.concurrent.locks.ReentrantLock;

// 演示可重入锁是什么意思

public class WhatReentrant2 {

public static void main(String[] args) {

ReentrantLock lock = new ReentrantLock();

new Thread(new Runnable() {

@Override

public void run() {

try {

lock.lock();

System.out.println("第1次获取锁，这个锁是：" + lock);

int index = 1;

while (true) {

try {

lock.lock();

System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);

try {

Thread.sleep(new Random().nextInt(200));

} catch (InterruptedException e) {

e.printStackTrace();

}

if (index == 10) {

break;

}

} finally {

lock.unlock();

}

}

} finally {

lock.unlock();

}

}

}).start();

}

}

2.8、synchronized买票案例回顾

真正的开发中，线程只是一个资源类(包含属性)，没有任何附属的操作

模拟卖票：

以前我们会将Ticket类继承Runnable接口现在会将Ticket作为一个资源类，里面不添加关于线程的操作

package com.zsr;

public class saleTicket {

public static void main(String[] args) {

//一份资源

Ticket ticket = new Ticket();

//多个线程

new Thread(() -> {

for (int i = 0; i < 30; i++) {

ticket.sale();

}

}, "A").start();

new Thread(() -> {

for (int i = 0; i < 20; i++) {

ticket.sale();

}

}, "B").start();

new Thread(() -> {

for (int i = 0; i < 80; i++) {

ticket.sale();

}

}, "C").start();

}

}

//资源类

class Ticket {

//票数

private int number = 100;

public synchronized void sale() {

if (number > 0)

System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票,剩余" + number);

}

}

三、Lock锁

3.1、简介

官方文档地址：https://tool.oschina.net/apidocs/apidoc?api=jdk-zh

使用方法：创建锁、加锁、业务代码、解锁

3.2、买票问题重现

我们接下来用Lock锁的方式来解决上述买票问题，Lock接口最常用的实现类就是ReentrantLock可重入锁

可以看到看到ReentrantLock有两个构造方法，可以指定使用 公平锁/非公平锁公平锁：十分公平，先来后到非公平锁：不公平，可以插队

修改Ticket类

//资源类

class Ticket2 {

//票数

private int number = 100;

//Lock锁

Lock lock = new ReentrantLock();

public void sale() {

lock.lock();//加锁

try {

if (number > 0)

System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票,剩余" + number);

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();//解锁

}

}

}

3.3、和Synchronized的区别

Synchronized是内置的关键字，Lock是一个Java类

Synchronized无法判断锁的状态，Lock可以判断是否获取到了锁

Synchronized会自动释放锁，Lock需要手动释放锁（如果不释放锁，会造成死锁）

假如有两个线程：线程1、线程2；线程1获得了锁

Synchronized：如果线程1阻塞了，线程2就会一直等待，造成死锁

Lock：如果线程1阻塞了，线程2不会一直等待，可以通过trylock()方法尝试获取锁

两者都是可重入锁，但是Synchronized不可中断，为非公平锁；而Lock锁可判断锁状态，并且可以设置为公平锁/非公平锁

Synchronized适合锁少量代码同步代码，Lock适合锁大量代码同步代码

四、生产者消费者问题(Lock版)

生产者消费者——线程之间的通信问题

通过Synchronized实现，我们常用 object.wait() + Object.notify()通过Lock怎么实现呢，用condition.await() + condition.signal()

4.1、Synchronized实现

两个线程A、B实现：

如果number不等于0，则number-1；如果number等于0，则number+1

package com.zsr;

public class communicate {

public static void main(String[] args) {

Data data = new Data();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "A").start();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "B").start();

}

}

class Data {

private int number = 0;

//如果number=0,则number+1

public synchronized void plus() throws InterruptedException {

if (number != 0)

this.wait();//等待

number++;

System.out.println(Thread.currentThread().getName() + "=>" + number);

this.notifyAll();//唤醒其他线程

}

//如果number!=0,则number-1

public synchronized void minor() throws InterruptedException {

if (number == 0)

this.wait();

number--;

System.out.println(Thread.currentThread().getName() + "=>" + number);

this.notifyAll();//唤醒其他线程

}

}

结果：

虚假唤醒问题

如果再加两个线程呢？

public static void main(String[] args) {

Data data = new Data();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "A").start();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "B").start();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "C").start();

new Thread(() -> {

for (int i = 0; i < 5; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "D").start();

}

}

看结果，会出现2、3的情况；这就是因为if判断只判断一次，两个线程可能同时+1；造成了虚假唤醒的问题 修改代码：if判断改成while判断

class Data {

private int number = 0;

//如果number=0,则number+1

public synchronized void plus() throws InterruptedException {

while (number != 0)

this.wait();//等待

number++;

System.out.println(Thread.currentThread().getName() + "=>" + number);

this.notifyAll();//唤醒其他线程

}

//如果number!=0,则number-1

public synchronized void minor() throws InterruptedException {

while (number == 0)

this.wait();

number--;

System.out.println(Thread.currentThread().getName() + "=>" + number);

this.notifyAll();//唤醒其他线程

}

}

4.2、Lock实现

修改代码：

package com.zsr;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class communicate2 {

public static void main(String[] args) {

Data2 data = new Data2();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "A").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "B").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "C").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "D").start();

}

}

class Data2 {

private int number = 0;

//创建Lock锁

private Lock lock = new ReentrantLock();

//获得condition

Condition condition = lock.newCondition();

//如果number=0,则number+1

public void plus() throws InterruptedException {

lock.lock();//加锁

try {

while (number != 0)

condition.await();//等待

number++;

System.out.println(Thread.currentThread().getName() + "=>" + number);

condition.signalAll();//唤醒其他线程

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();//解锁

}

}

//如果number!=0,则number-1

public void minor() throws InterruptedException {

lock.lock();

try {

while (number == 0)

condition.await();

number--;

System.out.println(Thread.currentThread().getName() + "=>" + number);

condition.signalAll();//唤醒其他线程

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

}

根据结果，成功实现！但是发现一个问题，线程的执行都是随机的，怎么进行有序的实现呢？A=>B=>C=>D

Condition精准通知唤醒

可以设置多个condition监视器，每个监视器监视一个线程，精确等待唤醒某个线程

package com.zsr;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class communicate3 {

public static void main(String[] args) {

Data3 data = new Data3();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "A").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "B").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.plus();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "C").start();

new Thread(() -> {

for (int i = 0; i < 10; i++) {

try {

data.minor();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}, "D").start();

}

}

class Data3 {

private int number = 0;

//创建Lock锁

private Lock lock = new ReentrantLock();

//获得condition

Condition conditionA = lock.newCondition();

Condition conditionB = lock.newCondition();

Condition conditionC = lock.newCondition();

Condition conditionD = lock.newCondition();

//如果number=0,则number+1

public void plus() throws InterruptedException {

lock.lock();//加锁

try {

if (Thread.currentThread().getName()=="A") {

while (number != 0)

conditionA.await();//A等待

number++;

System.out.println(Thread.currentThread().getName() + "=>" + number);

conditionB.signal();//唤醒B线程

}

if (Thread.currentThread().getName()=="C") {

while (number != 0)

conditionC.await();//C等待

number++;

System.out.println(Thread.currentThread().getName() + "=>" + number);

conditionD.signal();//唤醒D线程

}

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();//解锁

}

}

//如果number!=0,则number-1

public void minor() throws InterruptedException {

lock.lock();

try {

if (Thread.currentThread().getName()=="B") {

while (number == 0)

conditionB.await();//B等待

number--;

System.out.println(Thread.currentThread().getName() + "=>" + number);

conditionC.signal();//唤醒C线程

}

if (Thread.currentThread().getName()=="D") {

while (number == 0)

conditionD.await();//D等待

number--;

System.out.println(Thread.currentThread().getName() + "=>" + number);

conditionA.signal();//唤醒A线程

}

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

}

结果：

五、8个案例彻底理解锁的对象

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁（对象、 Class）

创建两个线程A、B，A线程执行发短信方法，B线程执行打电话方法，谁先执行？

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone = new Phone();

//线程A发消息

new Thread(() -> {

phone.send_message();

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

//线程B打电话

new Thread(() -> {

phone.call();

}, "B").start();

}

}

class Phone {

public synchronized void send_message() {

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

}

结果：先发短信再打电话

那如果让发短信休眠2s呢？

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone = new Phone();

new Thread(() -> {

try {

phone.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone.call();

}, "B").start();

}

}

class Phone {

public synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

}

结果：还是先发短信再打电话 这是为什么呢？并不是因为A先执行，而是有锁的存在

synchronized锁的对象是方法的调用者，也就是phone对象，因此打电话和发短信方法锁的是同一个对象，谁先拿到锁谁就先执行

如果新增一个普通方法hello，那先是hello还是发短信呢？

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone = new Phone();

new Thread(() -> {

try {

phone.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone.hello();

}, "B").start();

}

}

class Phone {

public synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

public void hello() {

System.out.println("hello");

}

}

根据结果，先执行hello，这是因为hello是一个普通方法，没有锁，不受锁的影响

如果有两个phone对象，是先发短信还是先打电话

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone1 = new Phone();

Phone phone2 = new Phone();

new Thread(() -> {

try {

phone1.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone2.call();

}, "B").start();

}

}

class Phone {

public synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

}

两个对象，两个调用者，所以有两把锁，所以按时间顺序执行

修改两个方法为静态方法，只有一个对象，是先打电话还是发短信

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone = new Phone();

new Thread(() -> {

try {

phone.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone.call();

}, "B").start();

}

}

class Phone {

public static synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public static synchronized void call() {

System.out.println("打电话");

}

}

根据结果，先发短信 因为static静态方法在类加载的时候就有了，因此这里synchronized锁的是Class模板，也就是Phone.class，全局唯一；也就是两个方法拿的仍是同一把锁

那如果两个方法为静态方法，有两个对象，是先打电话还是发短信？

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone1 = new Phone();

Phone phone2 = new Phone();

new Thread(() -> {

try {

phone1.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone2.call();

}, "B").start();

}

}

class Phone {

public static synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public static synchronized void call() {

System.out.println("打电话");

}

}

根据结果，仍是先发短信 因为锁的是Phone.class，也就是说两个方法仍是同一把锁

如果是一个普通的同步方法和一个静态的同步方法，只有一个对象

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone = new Phone();

new Thread(() -> {

try {

phone.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone.call();

}, "B").start();

}

}

class Phone {

public static synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

}

结果： 一个锁的是Phone.class模板，一个锁的是phone对象，因此两个方法不是一把锁，因此按时间顺序运行

如果是一个普通的同步方法和一个静态的同步方法，有两个对象

package com.zsr.lock8;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) throws InterruptedException {

Phone phone1 = new Phone();

Phone phone2 = new Phone();

new Thread(() -> {

try {

phone1.send_message();

} catch (InterruptedException e) {

e.printStackTrace();

}

}, "A").start();

//休眠1s

TimeUnit.SECONDS.sleep(1);

new Thread(() -> {

phone2.call();

}, "B").start();

}

}

class Phone {

public static synchronized void send_message() throws InterruptedException {

//休眠2s

TimeUnit.SECONDS.sleep(2);

System.out.println("发短信");

}

public synchronized void call() {

System.out.println("打电话");

}

}

同样两个方法不是一把锁，因此按时间顺序运行

六、安全集合类

6.1、CopyOnWriteArrayList

ArrayList不安全

并发情况下，ArrayList不安全，我们通过一个简单的案例来测试：

package com.zsr.collection;

import java.util.ArrayList;

import java.util.UUID;

public class ListTest {

public static void main(String[] args) {

//并发情况下

ArrayList list = new ArrayList<>();

for (int i = 0; i < 10; i++) {

new Thread(() -> {

list.add(UUID.randomUUID().toString().substring(0, 8));

System.out.println(list);

}, String.valueOf(i)).start();

}

}

}

根据结果，发现报错了ConcurrentModificationException（并发修改异常）

那么怎么解决呢？

方案一：换成线程安全的vector

Vector lists = new Vector<>();

方案二：利用Collections工具类

List list = Collections.synchronizedList(new ArrayList<>());

方案三：利用JUC包中的类CopyOnWriteArrayList

CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

引入CopyOnWriteArrayList

CopyOnWrite简称COW，是计算机程序设计领域的一种优化策略多个线程调用的时候，读取的时候固定，但写入时会复制，避免写入造成的数据覆盖问题

其效率比Vector更高，因为Vector在方法上都用了Synchronized关键字，会降低效率

而CopyOnWriteArratList是用Lock锁实现的，底层也是数组实现，不过添加的时候会先拷贝一份新的数组，最后再拷贝回去

6.2、CopyOnWriteArraySet

HashSet不安全

并发情况下，HashSet不安全，我们通过一个简单的案例来测试：

package com.zsr.collection;

import java.util.HashSet;

import java.util.UUID;

public class SetTest {

public static void main(String[] args) {

//并发情况下

HashSet set = new HashSet<>();

for (int i = 0; i < 30; i++) {

new Thread(() -> {

set.add(UUID.randomUUID().toString().substring(0, 8));

System.out.println(set);

}, String.valueOf(i)).start();

}

}

}

同样，ConcurrentModificationException：并发修改异常 那么怎么解决呢？

方案一：利用Collections工具类

Set set = Collections.synchronizedSet(new HashSet());

方案三：利用JUC包中的类CopyOnWriteArrayList

CopyOnWriteArraySet set = new CopyOnWriteArraySet<>();

引入CopyOnWriteArraySet

CopyOnWrite简称COW，是计算机程序设计领域的一种优化策略多个线程调用的时候，读取的时候固定，但写入时会复制，避免写入造成的数据覆盖问题

CopyOnWriteArratSet同样是用Lock锁实现的，底层也是数组实现，不过添加的时候会先拷贝一份新的数组，最后再拷贝回去

6.3、ConcurrentHashMap

HashMap不安全

并发情况下，HashMap不安全，我们通过一个简单的案例来测试：

package com.zsr.collection;

import java.util.HashMap;

import java.util.UUID;

public class MapTest {

public static void main(String[] args) {

//并发情况下

HashMap map = new HashMap<>();

for (int i = 0; i < 30; i++) {

new Thread(() -> {

map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 8));

System.out.println(map);

}, String.valueOf(i)).start();

}

}

}

同样，ConcurrentModificationException：并发修改异常 那么怎么解决呢？

方案一：利用Collections工具类

Map map = Collections.synchronizedMap(new HashMap());

方案三：利用JUC包中的类ConcurrentHashMap

ConcurrentHashMap map = new ConcurrentHashMap<>();

引入ConcurrentHashMap

ConcurrentHashMap融合了hashtable和hashmap二者的优势

但是hashtable每次同步执行的时候都要锁住整个结构。看下图：

ConcurrentHashMap正是为了解决这个问题而诞生的，其锁的方式是稍微细粒度的，引入了分段锁的概念；

可以理解为把一个大的Map拆分成N（默认为16）个小的HashTable，根据key.hashCode()来决定把key放到哪个HashTable中。

在ConcurrentHashMap中，就是把Map分成了N个Segment，put和get的时候，都是现根据key.hashCode()算出放到哪个Segment中：

通过把整个Map分为N个Segment（类似HashTable），可以提供相同的线程安全；原来只能一个线程进入，现在却能同时16个写线程进入（写线程才需要锁定，而读线程几乎不受限制），并发性的提升是显而易见的

七、Callable

7.1、同Runnable的区别

可以有返回值可以抛出异常重写call()方法而不是run()

7.2、怎么实现

实现Runnable接口时，我们通过Thread.start()进行启动，因为Thread的构造方法可以传入Runnable对象 那么怎么实现Callable呢？我们无法直接通过Thread进行启动，但是我们可以通过Runnable间接的启动 查看帮助文档，可以看到Runnable接口有一个FutureTask启动类，我们点进去看看 可以看到，它有两个构造方法，分别可以传入Callable和Runnable对象，这就将两者联系了起来 于事我们就可以通过Thread来启动Callable接口的实现类

package com.zsr;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

public class dome1 {

public static void main(String[] args) throws ExecutionException, InterruptedException {

myThread myThread = new myThread();

FutureTask futureTask = new FutureTask(myThread);

new Thread(futureTask).start();

System.out.println(futureTask.get());//获取call方法返回值

}

}

class myThread implements Callable {

@Override

public String call() throws Exception {

System.out.println("调用call方法");

return "call方法执行完成";

}

}

注意：

通过FutureTask的get()获取call方法的返回值，该方法可能会产生阻塞（可能返回结果需要大量的计算，很耗时），一般情况下将其放在最后一行或者使用异步通信来处理

FutureTask任务多线程并发访问时为啥只会被执行一次

八、三大常用辅助类

8.1、CountDownLatch

就是一个减法计数器

package com.zsr.countDown;

import java.util.concurrent.CountDownLatch;

public class Test {

public static void main(String[] args) throws InterruptedException {

//创建一个计数器,初始化为6

CountDownLatch countDownLatch = new CountDownLatch(6);

for (int i = 1; i <= 6; i++) {

new Thread(() -> {

System.out.println(Thread.currentThread().getName() + "线程执行结束");

countDownLatch.countDown();//计数器-1

}, String.valueOf(i)).start();

}

countDownLatch.await();//等待计数器归0再往下执行

System.out.println("所有线程执行完毕");

}

}

如果不加countDownLatch.await() 加了之后

8.2、CyclicBarrier

相当于加法计数器

package com.zsr.Cyclic;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class Test {

//模拟集齐7课龙珠召唤神龙

public static void main(String[] args) {

CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {

System.out.println("召唤神龙！");

});

for (int i = 1; i <= 7; i++) {

final int temp = i;

new Thread(() -> {

System.out.println(Thread.currentThread().getName() + "收集了第" + temp + "颗龙珠");

try {

cyclicBarrier.await();//计数不断+1,直到为7

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

}).start();

}

}

}

8.3、Semaphore

计数信号量

semaphore.acquire()，获得许可正，如果许可证已经满了，等待其他线程释放许可证semaphore.release()，释放许可证

作用：多个共享资源互斥使用，并发限流，控制最大的线程数

package com.zsr.Sema;

import java.util.concurrent.Semaphore;

import java.util.concurrent.TimeUnit;

public class Test {

public static void main(String[] args) {

//模拟3个车位,6辆车要停车

Semaphore semaphore = new Semaphore(3);

for (int i = 1; i <= 6; i++) {

new Thread(() -> {

try {

semaphore.acquire();//获取许可

System.out.println(Thread.currentThread().getName() + "抢到车位");

TimeUnit.SECONDS.sleep(2);

System.out.println(Thread.currentThread().getName() + "离开车位");

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

semaphore.release();//释放许可

}

}, String.valueOf(i)).start();

}

}

}

九、读写锁

代码测试：定义一个缓存区用于读写操作，然后启动5个线程分别进行读和写，测试

首先测试不加锁的情况下

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {

public static void main(String[] args) {

UnlockCache unlockCache = new UnlockCache();

//5个线程写入

for (int i = 1; i <= 5; i++) {

final int temp = i;

new Thread(() -> {

unlockCache.put(temp, temp);

}, String.valueOf(i)).start();

}

//5个线程读出

for (int i = 1; i <= 5; i++) {

final int temp = i;

new Thread(() -> {

unlockCache.get(temp);

}, String.valueOf(i)).start();

}

}

}

//不加锁的

class UnlockCache {

private volatile Map map = new HashMap<>();

//写入

public void put(int key, Object value) {

System.out.println("开始写入" + key);

map.put(key, value);

System.out.println(key + "写入完成");

}

//读出

public void get(int key) {

System.out.println("开始读取" + key);

map.get(key);

System.out.println(key + "读取完毕");

}

}

根据结果，可以看到写入时被插队，这是不允许的！

加读写锁，实现只能同时有一个线程写，多个线程读

也就是写锁为独占锁(一次只能被一个线程占有)，读锁为共享锁(多个线程可以同时占有)

读-读：可共存读-写：不可共存写-写：不可共存 import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {

public static void main(String[] args) {

LockCache lockCache = new LockCache();

//5个线程写入

for (int i = 1; i <= 5; i++) {

final int temp = i;

new Thread(() -> {

lockCache.put(temp, temp);

}, String.valueOf(i)).start();

}

//5个线程读出

for (int i = 1; i <= 5; i++) {

final int temp = i;

new Thread(() -> {

lockCache.get(temp);

}, String.valueOf(i)).start();

}

}

}

//加锁:实现同时只能有一个线程写,多个线程读

class LockCache {

private volatile Map map = new HashMap<>();

//读写锁:实现只能有一个线程写,多个线程写,更细粒度的控制

ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

//写入:只能有一个线程写

public void put(int key, Object value) {

readWriteLock.writeLock().lock();

try {

System.out.println("开始写入" + key);

map.put(key, value);

System.out.println(key + "写入完成");

} catch (Exception e) {

e.printStackTrace();

} finally {

readWriteLock.writeLock().unlock();

}

}

//读出:可以多个线程读

public void get(int key) {

readWriteLock.readLock().lock();

try {

System.out.println("开始读取" + key);

map.get(key);

System.out.println(key + "读取完毕");

} catch (Exception e) {

e.printStackTrace();

} finally {

readWriteLock.readLock().unlock();

}

}

}

根据结果，我们实现了写入时不能被插队，但是读取可以多个线程读取

十、阻塞队列

10.1、关系图

BlockingQueue关系图：

队列阻塞：

10.2、ArrayBlockingQueue四组API

方式抛出异常有返回值、不抛出异常阻塞等待限时等待添加add()offer()put()offer( , )移除remove()poll()take()poll( , )判断队列首element()peek()\\

抛出异常(add、remove、element)

//抛出异常

public static void test1() {

//初始化阻塞队列大小为3

ArrayBlockingQueue