多线程工具

最新推荐文章于 2024-06-04 22:35:01 发布

HKF~~

最新推荐文章于 2024-06-04 22:35:01 发布

阅读量396

点赞数

分类专栏： Java相关文章标签：多线程

本文链接：https://blog.csdn.net/acdHKF/article/details/118398443

版权

Java相关专栏收录该内容

14 篇文章 0 订阅

订阅专栏

CountDownLatch

CountDownLatch是 java.util.concurrent 包下一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。利用它可以实现类似计数器的功能。比如有一个任务 A，它要等待其他 4 个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch 来实现这种功能了。 CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。以下的应用场景是可以使用闭锁来实现的

 闭锁可以延迟线程的进度直到其到达终止状态

 闭锁可以用来确保某些活动直到其他活动都完成才继续执行：

 确保某个计算在其需要的所有资源都被初始化之后才继续执行;

 确保某个服务在其依赖的所有其他服务都已经启动之后才启动;

 等待直到某个操作所有参与者都准备就绪再继续执行。

//参数 count 为计数值

public CountDownLatch(int count) { };

//调用 await()方法的线程会被挂起，它会等待直到 count 值为 0 才继续执行

public void await() throws InterruptedException { };

//和 await()类似，只不过等待一定的时间后 count 值还没变为 0 的话就会继续执行

public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };

//将 count 值减 1 public void countDown() { };

import java.util.concurrent.CountDownLatch;

class CountDownLatchDemo {

public static void main(String[] args) {

final CountDownLatch latch = new CountDownLatch(2);

//任务 1

new Thread(() -> {

try {

System.out.println("任务 1 正在执行任务...");

Thread.sleep((long) (Math.random() * 1000));

System.out.println("任务 1 执行完毕...");

latch.countDown();

} catch (InterruptedException e) {

e.printStackTrace();

}

}).start();

new Thread(() -> {

try {

System.out.println("任务 2 正在执行任务...");

Thread.sleep((long) (Math.random() * 1000));

System.out.println("任务 2 执行完毕...");

latch.countDown();

} catch (InterruptedException e) {

e.printStackTrace();

}

}).start();

try {

latch.await();

System.out.println("其他两个任务执行完毕，主线程执行任务：" + Thread.currentThread().getName());

} catch (InterruptedException e) {

e.printStackTrace();

}

CountDownLatch 也是基于 AQS(AbstractQueuedSynchronizer) 实现的 • 初始化一个 CountDownLatch 时告诉并发的线程，然后在每个线程处理完毕之后调用 countDown() 方法。

• 该方法会将 AQS 内置的一个 state 状态 -1 。

• 最终在主线程调用 await() 方法，它会阻塞直到 state == 0 的时候返回。

CyclicBarrier循环栅栏

CyclicBarrier(循环栅栏)： CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

CyclicBarrier 默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用 await 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。 CyclicBarrier（回环栅栏-等待至 barrier 状态再全部同时执行）字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后， CyclicBarrier 可以被重用。我们暂且把这个状态就叫做 barrier，当调用 await()方法之后，线程就处于 barrier 了。 CyclicBarrier 中最重要的方法就是 await 方法，

它有 2 个重载版本：

1. public int await()：用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务；

2. public int await(long timeout, TimeUnit unit)：让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行后续任务。具体使用如下，另外 CyclicBarrier 是可以重用的

举例：公司组织周末聚餐吃饭，首先员工们（线程）各自从家里到聚餐地点，全部到齐之后，才开始一起吃东西（同步点）。假如人员没有到齐（阻塞），到的人只能够等待，直到所有人都到齐之后才开始吃饭。 CyclicBarrier(可循环的障碍物) 场景：在多线程计算数据之后，最后需要合并结果。

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CyclicBarrierDemo {

public static void main(String[] args) {

//3 个人聚餐

final CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {

@Override

public void run() {

System.out.println("人员全部到齐，开始拍照。。。。");

}

});

ExecutorService threadPool = Executors.newCachedThreadPool();

//模拟三个用户

for(int i = 0; i < 3; i++) {

final int user = i + 1;

Runnable r = new Runnable() {

@Override

public void run() {

try {

Thread.sleep((long)(Math.random()*10000));

System.out.println(user + "号到达聚餐点，当前已有" + (cb.getNumberWaiting() + 1)+"人到达");

//阻塞

cb.await();

Thread.sleep((long)(Math.random()*10000));

System.out.println(user + "号吃完饭，准备回家。。。");

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

};

threadPool.execute(r);

}

threadPool.shutdown();

}

Semaphore 信号量

限流、需要控制连接数的稀缺资源等 Semaphore(信号量)-允许多个线程同时访问： synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。

Semaphore 可以控制同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release()释放一个许可。 Semaphore 类中比较重要的几个方法：

1. public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

2. public void acquire(int permits):获取 permits 个许可

3. public void release() { } :释放许可。注意，在释放许可之前，必须先获获得许可。

4. public void release(int permits) { }:释放 permits 个许可

上面 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法 Semaphore 是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。

Semaphore 可以用来构建一些对象池，资源池之类的，比如数据库连接池

1. public boolean tryAcquire():尝试获取一个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false

2. public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false

3. public boolean tryAcquire(int permits):尝试获取 permits 个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false

4. public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits 个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false

5. 还可以通过 availablePermits()方法得到可用的许可数目。

例子：若一个工厂有 5 台机器，但是有 8 个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现：

import java.util.concurrent.Semaphore;

public class SemaphoreTest {

public static void main(String[] args) {

int N = 8;

Semaphore semaphore = new Semaphore(5); //机器数目

for (int i = 0; i < N; i++) {

new Worker(i, semaphore).start();

}

static class Worker extends Thread {

private int num;

private Semaphore semaphore;

public Worker(int num, Semaphore semaphore) {

this.num = num;

this.semaphore = semaphore;

}

@Override

public void run() {

try {

semaphore.acquire();

System.out.println("工人" + this.num + "占用一个机器在生产...");

Thread.sleep(2000);

System.out.println("工人" + this.num + "释放出机器");

semaphore.release();

} catch (InterruptedException e) {

e.printStackTrace();

}

Exchanger

业务需求三：绑架案，目的是为了用钱来赎人张三团伙绑架了小乔，放言要 1000 万来赎人，张三团伙和大乔同时到达约定的地点，然后一手交钱，一手交人两个线程，在同一个点（阻塞点），交换数据 Exchanger 两个线程进行交换数据。

场景：1.用于 2 个线程交换数据

2.校对工作

p

import java.util.concurrent.Exchanger;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ExchangerDemo {

public static void main(String[] args) {

//交换器，交换 String 类型

Exchanger<String> ec = new Exchanger<String>();

ExecutorService threadPool = Executors.newCachedThreadPool();

//张三团伙

threadPool.execute(() -> {

try {

String returnStr = ec.exchange("小乔");

System.out.println("绑架者用小乔交换回：" + returnStr);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

//大乔

threadPool.execute(()-> {

try {

String returnStr = ec.exchange("1000 万");

System.out.println("大乔用 1000 万交换回：" + returnStr);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

threadPool.shutdown();

}

HKF~~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程工具

CountDownLatchCountDownLatch是java.util.concurrent包下一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程...
复制链接

扫一扫