当前位置：首页 > news >正文

JUC并发工具---线程协作

news 2025/6/24 11:51:30

信号量能被FixedThreadPool代替吗

Semaphore信号量

控制需要限制访问量的资源，没有获取到信号量的线程会被阻塞

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;public class SemahoreDemo {static Semaphore semaphore = new Semaphore(3);public static void main(String[] args) {ExecutorService service = Executors.newFixedThreadPool(50);for (int i = 0; i < 1000; i++) {service.submit(new Task());   }service.shutdown();}static class Task implements Runnable {@Overridepublic void run() {try {// 获取信号量semaphore.acquire();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "拿到了许可证，花费2s执行慢服务");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("慢服务" + Thread.currentThread().getName() + "执行完毕，释放了许可证");// 释放信号量semaphore.release();}}
}

注意点

获取和释放的许可证数量尽量保持一致
在初始化的时候可以设置公平性
信号量是支持跨线程、跨线程池的，并且不是哪个线程获得到许可证，就必须由这个线程去释放。

CountDownLatch时如何安排线程执行顺序的

核心思想

等到一个设定的数值达到之后，才能出发。

用法

用法一：一个线程等待其他多个线程都执行完毕，再继续自己的工作

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CountDownLatchDemo1 {public static void main(String[] args) throws InterruptedException {CountDownLatch countDownLatch = new CountDownLatch(5);ExecutorService service = Executors.newFixedThreadPool(5);for (int i = 0; i < 5; i++) {final int no = i+1;Runnable runnable = new Runnable() {@Overridepublic void run() {try {Thread.sleep((long)(Math.random()*10000));System.out.println("Thread " + no + " is completed");} catch (InterruptedException e) {e.printStackTrace();}finally {// countDownLatch数量减一countDownLatch.countDown();}}};service.submit(runnable);}System.out.println("等待5个远动员都跑完...");// 等待countDownLatch中的数量减到某个阈值countDownLatch.await();System.out.println("5个远动员都跑完了,比赛结束");}
}

用法二：多个线程等待某一个线程的信号，同时开始执行

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CountDownLatchDemo2 {public static void main(String[] args) throws InterruptedException {System.out.println("远动员有5s的准备时间...");CountDownLatch countDownLatch = new CountDownLatch(1);ExecutorService service = Executors.newFixedThreadPool(5);for (int i = 0; i < 5; i++) {final int no = i+1;Runnable runnable = new Runnable() {@Overridepublic void run() {System.out.println("Thread " + no + " 开始准备完毕，等待裁判员的发号");try {// 等待countDownLatch减到某个阈值countDownLatch.await();System.out.println("Thread " + no + "运动员开始跑步");} catch (InterruptedException e) {e.printStackTrace();}}};service.submit(runnable);}Thread.sleep(5000);System.out.println("5秒准备时间已过，发令枪响，比赛开始");countDownLatch.countDown();;}
}

CyclicBarrier和CountDownLatch是有什么异同

相同点：都能阻塞一个或者一组线程，直到某种预定的条件达到之后，之前在等待的线程才会统一出发，继续向下执行。

不同点：

作用对象不同，CyclicBarrier要等固定数量的线程都到达了栅栏位置才能继续执行，而CountDownLatch只需要等待数字倒数到0。CountDownLatch作用于事件，但CyclicBarrier作用于线程。CountDownLatch是在调用了countDown方法之后把数字倒数减1，而 CyclicBarrier是在某线程开始等待后把计数减1。
可重用性不同，CountDownLatch在倒数到O并且触发门门打开后，就不能再次使用了，除非新建一个新的实例，而CyclicBarrier可以重复使用，并不需要重新新建实例，CyclicBarrier还可以随时调用reset方法进行重置。如果重置时有线程已经调用了await方法并开始等待，那么线程则会抛出BrokenBarrierException异常。
执行动作不同，CyclicBarriar有执行动作barrierAction，而 CountDownLatch 没这个功能。

CyclicBarrier当预设数量的线程到达集结点之后，出发时，便会执行传入的Runnable对象。

import java.util.concurrent.CyclicBarrier;public class CyclicBarrierDemo {public static void main(String[] args) {CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println("所有线程到达栅栏，继续执行");}});for (int i = 1; i <= 3; i++) {final int threadNum = i;new Thread(new Runnable() {@Overridepublic void run() {try {System.out.println("线程" + threadNum + "开始执行");// 模拟任务执行Thread.sleep(1000);System.out.println("线程" + threadNum + "任务完成，等待其他线程");// await表示+1，也就是要等到3，才会执行cyclicBarrier中的runcyclicBarrier.await(); // 线程在此处等待其他线程} catch (Exception e) {e.printStackTrace();}}}).start(); // 启动线程}}
}

Condition、object.wait()和notify()的关系

Condition接口的作用

线程1需要等到某些条件满足后，才能继续运行，这个时候就要Condition的await方法，线程就会进入WAITING状态。

另外一个线程2，达到对应的条件，直到条件达成，线程2调用Condition的signal()或者signalAll()，表示“这个条件已经达成了，之前等待这个条件的线程现在可以苏醒了”，JVM会找到等待该Condition的线程，并予以唤醒根据调用的是signal方法或signalAll方法，唤醒1个或所有的线程

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;public class ConditionDemo {private ReentrantLock lock = new ReentrantLock();private Condition condition = lock.newCondition();public void method1() throws InterruptedException {lock.lock();try {System.out.println(Thread.currentThread().getName() + ":条件不满足，开始await");condition.await();System.out.println(Thread.currentThread().getName() + ":条件满足了，开始执行后续的任务");} finally {lock.unlock();}}public void method2() throws InterruptedException {lock.lock();try {System.out.println(Thread.currentThread().getName() + ":需要5s的准备时间");Thread.sleep(5000);System.out.println(Thread.currentThread().getName() + ":准备工作完成，唤醒其它线程");// condition.signal()唤醒正在等待当前条件的线程condition.signal();} finally {lock.unlock();}}public static void main(String[] args) throws InterruptedException {ConditionDemo demo = new ConditionDemo();new Thread(new Runnable() {@Overridepublic void run() {try {demo.method2();} catch (InterruptedException e) {e.printStackTrace();}}}, "Thread-2").start();// 方法开始等待demo.method1();}
}