· ReentrantLock
· Semaphore
· CountDownLatch
· CyclicBarrier
1、ReentrantLock：可重入锁
老朋友了，看前面博客
2、Semaphore：信号量可以实现限流操作，给一个线程池添加多个任务，借助信号量可以实现对线程执行情况的控制：
两个重要的方法：
①semaphore.acquire（）获得信号量
②semaphore.release（）释放信号量
public class SemaphoreDemo1 {
public static void main(String[] args) {
//创建线程池
ExecutorService service =Executors.newFixedThreadPool(5);
//创建信号量
Semaphore semaphore = new Semaphore(2);
//统一的任务
Runnable runnable = new Runnable() {
@Override
public void run() {
Thread currThread= Thread.currentThread();//获得当前的线程
System.out.println("进入线程："+currThread.getName());
try {
//获取令牌
semaphore.acquire();//如果没有可用令牌，那么线程会阻塞在当前位置
System.out.println(currThread.getName()+":得到了令牌 | Time:"+
LocalDateTime.now());
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println(currThread.getName()+":释放了令牌 | Time:"+
LocalDateTime.now());
//释放令牌
semaphore.release();
}
}
};
//提交任务给线程池执行
service.submit(runnable);
//提交任务给线程池执行
service.submit(runnable);
//提交任务给线程池执行
service.submit(runnable);
//提交任务给线程池执行
service.submit(runnable);
//提交任务给线程池执行
service.submit(runnable);
}
}
3、CountDownLatch：计数器
在多个线程中，可以用join等待所有的线程都执行结束，而在线程池中呢？join就不行了，这个时候可以使用CountDownLatch，来判断线程池中的任务是否已经全部执行完。比如比赛的时候需要等所有选手到达终点之后再公布成绩。
两个重要方法：
①countDown：计数器-1
②await：阻塞等待，所有的任务全部执行完（等待CountDownLatch==0）
public class CountDownLatchDemo1 {
public static void main(String[] args) throws InterruptedException {
//创建计数器
CountDownLatch countDownLatch = new CountDownLatch(5);
//创建新线程执行任务
for (int i =1 ; i <6 ; i++) {
int finalI = i;
new Thread(()->{
Thread currThread = Thread.currentThread();
System.out.println(currThread.getName()+"开始起跑");
//跑步所用的时间
try {
int runTime = (1+new Random().nextInt(5));
TimeUnit.SECONDS.sleep(runTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前选手到达终点："+ finalI);
countDownLatch.countDown();
},"选手-"+i).start();
}
countDownLatch.await();
System.out.println("比赛结束");
}
}
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class CountDownLatchDemo2 {
public static void main(String[] args) throws InterruptedException {
//创建计数器
CountDownLatch countDownLatch = new CountDownLatch(2);
//创建线程池
ExecutorService service = Executors.newFixedThreadPool(5);
//给线程池添加任务
for (int i = 0; i < 2; i++) {
service.submit(new Runnable() {
@Override
public void run() {
Thread currThread = Thread.currentThread();
System.out.println("线程名称："+currThread.getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(currThread.getName()+"执行结束");
countDownLatch.countDown();
}
});
}
countDownLatch.await();
System.out.println("比赛结束");
}
}
4、CyclicBarrier：循环屏障
通过循环屏障可以实现对多线程的并发控制，只有被阻塞的线程数量到达指定值时屏障才会放行。实际上，它也可以看作一个倒计时器，倒计时数的最大值即为屏障值，每个线程调用了await方法都会使倒计时器的数减一，当倒计时数的值为零时，冲破屏障，继续执行下面的代码。再举一个简单的例子，冲破屏障就像现实生活中大坝泄洪，等水到达一定量时，再进行开闸放水，只不过这个过程是循环的，泄完这一波，又重新开始储水，等到达一定量时再继续泄。
public class CyclicBarrierDemo1 {
public static void main(String[] args) throws InterruptedException {
//循环屏障
CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
@Override
public void run() {
System.out.println("计数器为0了");
}
});
//创建线程池
ExecutorService service =Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
int finalI = i;
service.submit(()->{
Thread currThread = Thread.currentThread();
System.out.println("执行线程："+currThread.getName());
try {
Thread.sleep(500* finalI);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
cyclicBarrier.await();//执行阻塞（计数器-1，阻塞等待，直到循环屏障的计数器为0的时候，再执行后面的代码）
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("线程执行完成："+currThread.getName());
});
}
}
}
结果展示：
