版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_35704236/article/details/78237231
Concurrent.util 常用类的介绍和使用
CyclicBarrier
假设一个场景： 每个线程都代表一个跑步运动员，当运动员都准备好后才一起出发，只要有一个没准备好，大家都等待。
package org.mulity.demo;
import java.util.Random;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* CyclicBarrier 使用示例
*
* Created by jun on 2017/10/14.
*/
public class UseCyclicBarrier {
static class Runner implements Runnable {
private CyclicBarrier barrier;
private String name;
public Runner(CyclicBarrier barrier, String name) {
this.barrier = barrier;
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(1000 * (new Random()).nextInt(5));
System.out.println(name + ", ready");
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(name + "GO!");
}
}
public static void main(String[] args) {
// new CyclicBarrier(3); 必须有 3 个barrier.await(); 才能继续往下执行
CyclicBarrier barrier = new CyclicBarrier(3);
// 返回一个固定数量的线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
executor.submit(new Thread(new Runner(barrier, "运动员1")));
executor.submit(new Thread(new Runner(barrier, "运动员2")));
executor.submit(new Thread(new Runner(barrier, "运动员3")));
}
}
// 输出：
运动员2, ready
运动员3, ready
运动员1, ready
运动员1GO!
运动员2GO!
运动员3GO!CountDownLacth
它常用于监听某些初始化操作，等初始化操作执行完毕后，通知主线程继续工作
package org.mulity.demo;
import java.util.concurrent.CountDownLatch;
/**
* CountDownLatch 使用示例
* <p>
* Created by jun on 2017/10/14.
*/
public class UserCountDownLatch {
public static void main(String[] args) {
final CountDownLatch countDown = new CountDownLatch(2);
// CountDownLatch(2) 代表一个 countDown.await(); 需要两个countDown.countDown();来唤醒
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("进入线程1：等待其他线程处理完成");
countDown.await();
System.out.println("t1 线程继续执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("进入线程2：线程开始初始化");
Thread.sleep(3000);
countDown.countDown();
System.out.println("t2 线程初始化完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t2");
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("进入线程3：线程开始初始化");
Thread.sleep(3000);
countDown.countDown();
System.out.println("t3 线程初始化完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t3");
t1.start();
t2.start();
t3.start();
}
}
// 输出：
进入线程2：线程开始初始化
进入线程3：线程开始初始化
进入线程1：等待其他线程处理完成
t2 线程初始化完毕
t3 线程初始化完毕
t1 线程继续执行
Callable 和 Future
Future 模式 有点类似于 ajax 异步的调用，非常适合在处理耗时很长的业务逻辑的时候使用，可以有效的减小系统的响应时间，提高系统的吞吐量
package org.mulity.demo;
import java.util.concurrent.*;
/**
* Future 使用示例
*
* Created by jun on 2017/10/14.
*/
public class UseFuture implements Callable<String>{
private String para;
public UseFuture(String para) {
this.para = para;
}
/**
* 这里是真实的业务逻辑，执行起来可能比较慢
*/
@Override
public String call() throws Exception {
// 模拟执行耗时
Thread.sleep(3000);
return this.para + "处理完成";
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
String queryStr = "query";
FutureTask future = new FutureTask<String>(new UseFuture(queryStr));
// 该方法会创建一个线程的线程池，若空闲则执行，若没有空闲线程，则缓存在任务队列中
ExecutorService executor = Executors.newSingleThreadExecutor();
Future f = executor.submit(future);
System.out.println("请求完毕");
// 主程序可以执行其他业务逻辑
Thread.sleep(1000);
// future.get() 没得到数据前会阻塞
System.out.println("数据：" + future.get());
executor.shutdown();
}
}// 输出
请求完毕
数据：query处理完成Samaphore 信号量
常用于高并发下，Java 层面，系统的限流。
package org.mulity.demo;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* Semaphore 示例
*
* Created by jun on 2017/10/14.
*/
public class UseSemaphore {
public static void main(String[] args) {
// 返回一个可以根据实际情况调整线程个数的线程池，不限制最大的线程数量，若有空闲的线程，则执行任务，若无任务则不创建线程，并且每一个空闲线程会在60秒后自动回收
ExecutorService executor = Executors.newCachedThreadPool();
// 同时只能有 5 个线程同时访问
final Semaphore semp = new Semaphore(5);
// 模拟 20个线程同时访问
for (int index = 0; index < 20; index++) {
final int NO = index;
Runnable run = new Runnable() {
@Override
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println(NO + "已经获取许可");
// 模拟实际业务逻辑
Thread.sleep(1000 * (new Random()).nextInt(10));
// 释放许可
semp.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
executor.submit(run);
}
}
}// 输出:
0已经获取许可
1已经获取许可
2已经获取许可
3已经获取许可
4已经获取许可
5已经获取许可
6已经获取许可
7已经获取许可
...