目录
一、Callable（简单）
1、官方文档描述
2、启动线程
启动线程的方法只有一个：
但是Thread()的参数不能传入callable：
我们需要借助Runnable的实现类FutureTask传入Callable：
运行结果：
注意：
FutureTask：
二、CountDownLatch（“减法”计数器）
1、概述
官方文档介绍：
2、代码演示
代码实现：
运行结果：
3、方法简述
三、CyclicBarrier（“加法”计数器）
1、概述
官方文档介绍：
2、代码演示
代码实现：
运行结果：
四、Semaphore（计数信号量）
1、概述
官方文档介绍：
2、代码演示
代码实现：
运行结果：
3、方法简介
acquire()：
release()：
一、Callable（简单）
1、官方文档描述
①可以有返回值；
②可以抛出异常；
③方法不同：call()方法（Runnable是run()方法）；
2、启动线程
启动线程的方法只有一个：
new Thread().start();
但是Thread()的参数不能传入callable：
那可怎么办？
我们需要借助Runnable的实现类FutureTask传入Callable：
package com.zibo.callable;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//测试Callable
public class TestCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyThread myThread = new MyThread();
FutureTask futureTask = new FutureTask(myThread);
new Thread(futureTask,"A").start();
new Thread(futureTask,"B").start();//结果会被缓存，提升效率
//futureTask.get()获取callable的返回值
System.out.println(futureTask.get());//这个get方法会被阻塞，放到最后
}
}
class MyThread implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("call()执行了！" + Thread.currentThread().getName());
return "123";
}
}
运行结果：
call()执行了！A
123
注意：
有缓存；结果可能需要等待，会阻塞；
FutureTask：
二、CountDownLatch（“减法”计数器）
1、概述
官方文档介绍：
2、代码演示
代码实现：
package com.zibo.add;
import java.util.concurrent.CountDownLatch;
//线程计数器
public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
//创建线程计数器，初始化值为6，也就是说，倒数6条线程，走完结束
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 0; i < 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "线程执行完了!");
//线程执行完毕，线程计数器减1
countDownLatch.countDown();
},String.valueOf(i)).start();
}
countDownLatch.await();//等待计数器归零，然后向下执行
System.out.println("6个线程执行完毕！");
}
}
运行结果：
0线程执行完了!
4线程执行完了!
3线程执行完了!
2线程执行完了!
1线程执行完了!
5线程执行完了!
6个线程执行完毕！
3、方法简述
countDown()：使得计数器数量减1；
await()：当计数器为0，继续执行下面的方法；
三、CyclicBarrier（“加法”计数器）
1、概述
官方文档介绍：
2、代码演示
（集齐7颗龙珠，召唤神龙！）
代码实现：
package com.zibo.add;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
//“加法”计数器
public class TestCyclicBarrier {
public static void main(String[] args) {
//创建计数器，参数1是计数数量，参数2是达到数量时执行的线程
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
System.out.println("召唤神龙！");
});
//走7条线程
for (int i = 0; i < 7; i++) {
int finalI = i;
new Thread(()->{
System.out.println(Thread.currentThread().getName() + "搜集了第" + finalI + "颗龙珠！");
try {
cyclicBarrier.await();//等待
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
运行结果：
0搜集了第0颗龙珠！
4搜集了第4颗龙珠！
6搜集了第6颗龙珠！
3搜集了第3颗龙珠！
2搜集了第2颗龙珠！
1搜集了第1颗龙珠！
5搜集了第5颗龙珠！
召唤神龙！
四、Semaphore（计数信号量）
1、概述
官方文档介绍：
2、代码演示
（抢车位：6辆车，3个车位）
代码实现：
package com.zibo.add;
import java.util.concurrent.Semaphore;
//信号量
public class TestSemaphore {
public static void main(String[] args) {
//线程数量，停车位3个
Semaphore semaphore = new Semaphore(3);
//6个线程执行，6辆车
for (int i = 0; i < 6; i++) {
new Thread(()->{
//acquire()：从信号量获取许可证
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "线程拿到许可证，抢到车位，停车！");
System.out.println(Thread.currentThread().getName() + "线程释放许可证，开车离开！");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//release()：释放许可证，返回到信号量
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}
运行结果：
0线程拿到许可证，抢到车位，停车！
2线程拿到许可证，抢到车位，停车！
2线程释放许可证，开车离开！
1线程拿到许可证，抢到车位，停车！
1线程释放许可证，开车离开！
0线程释放许可证，开车离开！
3线程拿到许可证，抢到车位，停车！
3线程释放许可证，开车离开！
5线程拿到许可证，抢到车位，停车！
5线程释放许可证，开车离开！
4线程拿到许可证，抢到车位，停车！
4线程释放许可证，开车离开！
3、方法简介
acquire()：
从信号量获取许可证（业务代码执行前获取）；
release()：
释放许可证到信号量（业务代码执行后释放）；
