这次说说多线程只是扩展，主要讲解一些应用，应用带一些原理讲解，同时希望各位老铁有所收获，这些内容跟前面的线程和并发容器有关系的，从应用场景引出多线程技术栈里面的应用，其实锁和同步块，容器，工具类，都是非常的使用的。反射更加适应于语法。
（一）多线程应用
- ① 介绍
多线程经常使用在逻辑处理里面，一个程序N个逻辑要做，一个用户请求可能需要数据库查询，第三方的系统接口，调用redis，一个用户请求需要多步组成，可以使用多线程技术来实现，去做一些调整，
- ② 经典场景
接触后端开发的时候，经常发现一个请求过来，后端需要做一系列的复杂的操作，下面这个后端有：系统消息，我的团队，我的钱包 对于这些信息，后面的系统如何设计。这些可能涉及到多个模块的调用。一个系统划分为多个子系统来做。
- ③ 后端接口执行-大概流程
互联网公司存在组织结构复杂，调用的模块比较多。设计这样系统的时候，一个信息单独的查询系统的对应接口，还是移动前端发起一次请求一下获取到。一般都做网关（API）接口，一个请求获取多个信息，网关收到信息后，获取多个子系统的接口，最后把信息汇总，返回给前端。
- 收到一个请求。
- 调用多个服务接口获取其他系统的数据信息。
- 最后汇总范围。
通过数据分析，越来越多的互联网电商平台的单子70%以上都来自手机端，手机端有个典型的应用，网络处理很麻烦的，移动设备的固有属性，一个人走这走这到了信号的盲区了，一个页面发起五六个接口的请求，移动互联网的应用造成了很大的损耗，一般都是一个接口获取全部的信息。
如果一个API网关需要调用3个接口，这3个接口是串行完成的，A执行完（3秒），执行B，B执行完（2秒），执行C（5秒），C执行完返回给移动端json字符串，需要10秒才能返回。
如果A，B，C这3个没有相互依赖的关系，完全可以把A交给线程1，B交给线程2，C交给线程3，来一起去完成，汇总执行的结果，需要5秒，没完成就返回。这样是不是效率明显得到了提升。
（二）Future
- ① 介绍
异步计算的结果，提供了用于检查计算是否完成，等待计算完成以及获取结果的方法。
- ② 接口的定义
- boolean cancel(boolean mayInterruptIfRunning)
尝试取消当前任务的执行。如果任务已经取消、已经完成或者其他原因不能取消，尝试将失败。如果任务还没有启动就调用了cancel(true)，任务将永远不会被执行。如果任务已经启动，参数mayInterruptIfRunning将决定任务是否应该中断执行该任务的线程，以尝试中断该任务。
如果任务不能被取消，通常是因为它已经正常完成，此时返回false，否则返回true
- boolean isCancelled()
如果任务在正常结束之前被被取消返回true
3.boolean isDone()
正常结束、异常或者被取消导致任务完成，将返回true
4.V get()
等待任务结束，然后获取结果，如果任务在等待过程中被终端将抛出InterruptedException，如果任务被取消将抛出CancellationException，如果任务中执行过程中发生异常将抛出ExecutionException。
5.V get(long timeout, TimeUnit unit)
任务最多在给定时间内完成并返回结果，如果没有在给定时间内完成任务将抛出TimeoutException。
（三）CountDownLatch
- ① 介绍
一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
- ② 常见用法
多个人等一个信号后继续执行操作。例如5个运动员，等一个发令员的枪响。
一个人等多个人的信号。旅游团等所有人签到完成才开始出发。
常见到使用的地方是zk获取连接的时候。
- ③ 源码分析
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class UserServiceCountLatch {
ExecutorService executorService = Executors.newCachedThreadPool();
@Autowired
private RestTemplate restTemplate;
/**
* 查询多个系统的数据，合并返回
*/
public Object getUserInfo(String userId) throws InterruptedException {
CountDownLatch count = new CountDownLatch(2);
ArrayList<JSONObject> values = new ArrayList<>();
// 你可以封装成一个 提交URL 就能自动多线程调用的 工具
executorService.submit(() -> {
// 1.业务代码
JSONObject userInfo = new JSONObject();
values.add(userInfo);
count.countDown();
});
executorService.submit(() -> {
// 2.业务代码
JSONObject intergralInfo= new JSONObject();
values.add(intergralInfo);
count.countDown();
});
count.await();// 等待计数器归零
// 3. 合并为一个json对象
JSONObject result = new JSONObject();
for (JSONObject value : values) {
result.putAll(value);
}
return result;
}
}
1.统计线程执行的情况
2.压力测试中，使用countDownLatch实现最大程度的并发处理。
2.多个线程之间，相互通信，比如线程异步调用完接口，结果通知。
（四）CyclicBarrier
- ① 介绍
CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。
- ② 场景
坐车，老板都是票卖完了才开车。
数据库的批量操作，达到一定数量批量进行插入。
- ③ 源码
import java.util.ArrayList;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
// 循环屏障(栅栏)，示例：数据库批量插入
// 游戏大厅... 5人组队打副本
public class CyclicBarrierTest {
public static void main(String[] args) throws InterruptedException {
LinkedBlockingQueue<String> sqls = new LinkedBlockingQueue<>();
// 任务1+2+3...1000 拆分为100个任务（1+..10, 11+20） -> 100线程去处理。
// 每当有4个线程处于await状态的时候，则会触发barrierAction执行
CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
@Override
public void run() {
// 这是每满足4次数据库操作，就触发一次批量执行
System.out.println("有4个线程执行了，开始批量插入： " + Thread.currentThread());
for (int i = 0; i < 4; i++) {
System.out.println(sqls.poll());
}
}
});
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
sqls.add("data - " + Thread.currentThread()); // 缓存起来
Thread.sleep(1000L); // 模拟数据库操作耗时
barrier.await(); // 等待栅栏打开,有4个线程都执行到这段代码的时候，才会继续往下执行
System.out.println(Thread.currentThread() + "插入完毕");
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
Thread.sleep(2000);
}
}
（五）Semaphore
- ①介绍
又称“信号量”，控制多个线程争抢许可。
acquire: 获取一个许可，如果没有就等待。
release: 释放一个许可。
availablePermits: 方法得到可用的许可数目。
- ② 场景
代码并发处理限流
举个例子，去洗浴中心的时候都会给一个手环，这个手环很多时候就是为了限制熟练，因为柜子是有限的，每个人一个柜子，如果没有手环了就是没有柜子了，手环归还后柜子就出现了，基本就是这个原理。
- ③ 源码
import com.study.lock.aqs.NeteaseAqs;
// 自定义的信号量实现
public class NeteaseSemaphore {
NeteaseAqs aqs = new NeteaseAqs() {
@Override
public int tryAcquireShared() { // 信号量获取， 数量 - 1
for(;;) {
int count = getState().get();
int n = count - 1;
if(count <= 0 || n < 0) {
return -1;
}
if(getState().compareAndSet(count, n)) {
return 1;
}
}
}
@Override
public boolean tryReleaseShared() { // state + 1
return getState().incrementAndGet() >= 0;
}
};
/** 许可数量 */
public NeteaseSemaphore(int count) {
aqs.getState().set(count); // 设置资源的状态
}
public void acquire() {
aqs.acquireShared();
} // 获取令牌
public void release() {
aqs.releaseShared();
} // 释放令牌
}
import com.study.lock.aqs.AQSdemo;
import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
// 信号量机制
public class SemaphoreDemo {
public static void main(String[] args) {
SemaphoreDemo semaphoreTest = new SemaphoreDemo();
int N = 9; // 客人数量
NeteaseSemaphore semaphore = new NeteaseSemaphore(5); // 手牌数量，限制请求数量
for (int i = 0; i < N; i++) {
String vipNo = "vip-00" + i;
new Thread(() -> {
try {
semaphore.acquire(); // 获取令牌
semaphoreTest.service(vipNo);
semaphore.release(); // 释放令牌
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
// 限流 控制5个线程 同时访问
public void service(String vipNo) throws InterruptedException {
System.out.println("楼上出来迎接贵宾一位，贵宾编号" + vipNo + "，...");
Thread.sleep(new Random().nextInt(3000));
System.out.println("欢送贵宾出门，贵宾编号" + vipNo);
}
}
package com.study.lock.aqs;
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;
// 抽象队列同步器
// state， owner， waiters
public class NeteaseAqs {
// acquire、 acquireShared ： 定义了资源争用的逻辑，如果没拿到，则等待。
// tryAcquire、 tryAcquireShared ： 实际执行占用资源的操作，如何判定一个由使用者具体去实现。
// release、 releaseShared ： 定义释放资源的逻辑，释放之后，通知后续节点进行争抢。
// tryRelease、 tryReleaseShared： 实际执行资源释放的操作，具体的AQS使用者去实现。
// 1、 如何判断一个资源的拥有者
public volatile AtomicReference<Thread> owner = new AtomicReference<>();
// 保存 正在等待的线程
public volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
// 记录资源状态
public volatile AtomicInteger state = new AtomicInteger(0);
// 共享资源占用的逻辑，返回资源的占用情况
public int tryAcquireShared(){
throw new UnsupportedOperationException();
}
public void acquireShared(){
boolean addQ = true;
while(tryAcquireShared() < 0) {
if (addQ) {
// 没拿到锁，加入到等待集合
waiters.offer(Thread.currentThread());
addQ = false;
} else {
// 阻塞 挂起当前的线程，不要继续往下跑了
LockSupport.park(); // 伪唤醒，就是非unpark唤醒的
}
}
waiters.remove(Thread.currentThread()); // 把线程移除
}
public boolean tryReleaseShared(){
throw new UnsupportedOperationException();
}
public void releaseShared(){
if (tryReleaseShared()) {
// 通知等待者
Iterator<Thread> iterator = waiters.iterator();
while (iterator.hasNext()) {
Thread next = iterator.next();
LockSupport.unpark(next); // 唤醒
}
}
}
// 独占资源相关的代码
public boolean tryAcquire() { // 交给使用者去实现。 模板方法设计模式
throw new UnsupportedOperationException();
}
public void acquire() {
boolean addQ = true;
while (!tryAcquire()) {
if (addQ) {
// 没拿到锁，加入到等待集合
waiters.offer(Thread.currentThread());
addQ = false;
} else {
// 阻塞 挂起当前的线程，不要继续往下跑了
LockSupport.park(); // 伪唤醒，就是非unpark唤醒的
}
}
waiters.remove(Thread.currentThread()); // 把线程移除
}
public boolean tryRelease() {
throw new UnsupportedOperationException();
}
public void release() { // 定义了 释放资源之后要做的操作
if (tryRelease()) {
// 通知等待者
Iterator<Thread> iterator = waiters.iterator();
while (iterator.hasNext()) {
Thread next = iterator.next();
LockSupport.unpark(next); // 唤醒
}
}
}
public AtomicInteger getState() {
return state;
}
public void setState(AtomicInteger state) {
this.state = state;
}
}
PS：工具是根据场景来的，达到某个场景这个工具才有它的价值，如果你不存在这个场景这个工具也就没有价值。多线程这块设计到3块的知识：筑基阶段（JMM，lock，cas，atomic，sync），并发容器（。里面都涉及到数据结构，我已经开通了专辑数据结构与算法，数据结构并不是一两篇文章就可以搞定的东西，大学可是一门学科。），工具类阶段（多线程工具类阶段，设计模式的体现。不同的源码都有自己的设计模式的体现）
