Concurrent.util常用类

最新推荐文章于 2024-04-10 23:25:13 发布

miaokezhang

最新推荐文章于 2024-04-10 23:25:13 发布

阅读量178

点赞数

分类专栏： baidu

baidu 专栏收录该内容

9 篇文章

订阅专栏

本文详细解析了Java并发控制中的CyclicBarrier和CountDownLatch的使用场景及实现方式，通过具体代码示例展示了如何利用这两种工具类来同步线程间的运行，确保在所有参与线程准备就绪后，再统一执行后续操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

CyclicBarrier使用：
想象成一个场景：每一个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个没有准备好，大家都等待。
多个阻塞线程等待着一个barrier确定。

package t18;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class UserCyclicBarrier {

	static class Runner implements Runnable{
		
		private String name;
		private CyclicBarrier barrier;

		public Runner(CyclicBarrier barrier,String name){
			this.barrier = barrier;
			this.name = name;
		}
		
		@Override
		public void run() {
			try {
				System.out.println("好了，运动员" + name + "已经准备就绪了~");
				barrier.await();//运动员进入阻塞等待
				Thread.sleep(3000);
				System.out.println(name + "gogogo！！");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}		
		
		public static void main(String[] args) {
			
			CyclicBarrier barrier = new CyclicBarrier(3);
			
			ExecutorService executor = Executors.newFixedThreadPool(3);
			
			executor.submit(new Runner(barrier, "张三"));
			executor.submit(new Runner(barrier, "李四"));
			executor.submit(new Runner(barrier, "王五"));
			
			executor.shutdown();
		}
	}
}

输出结果：

好了，运动员张三已经准备就绪了~
好了，运动员李四已经准备就绪了~
好了，运动员王五已经准备就绪了~
张三gogogo！！
王五gogogo！！
李四gogogo！！

CountDownLacth使用：
他常用于监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作。一个线程等待多个操作完成。

package t18;

import java.util.concurrent.CountDownLatch;

public class UserCountDownLatch {
	
	public static void main(String[] args) {
		
		final CountDownLatch countDown = new CountDownLatch(2);
		
		Thread t1 = new Thread(new Runnable(){

			@Override
			public void run() {
				
				try {
					System.out.println("进入线程t1" + "等待其他线程处理完成...");
					
					countDown.await();
					System.out.println("t1线程继续执行~");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			
			
			
		},"t1");
		
		Thread t2 = new Thread(new Runnable(){

			@Override
			public void run() {
				
				try {
					System.out.println("t2线程进行初始化操作(3s)...");
					Thread.sleep(3000);
					System.out.println("t2线程初始化完成~");
					countDown.countDown();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			
		},"t2");
		
		
		Thread t3 = new Thread(new Runnable(){

			@Override
			public void run() {
				try {
					System.out.println("t3线程进行初始化操作(2s)...");
					Thread.sleep(2000);
					System.out.println("t3线程初始化完成~");
					countDown.countDown();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		},"t3");
		
		
		t1.start();
		t2.start();
		t3.start();
	}

}

输出结果：

t3线程进行初始化操作(2s)...
进入线程t1等待其他线程处理完成...
t2线程进行初始化操作(3s)...
t3线程初始化完成~
t2线程初始化完成~
t1线程继续执行~

Callable和Future的使用：
Future模式非常适合在处理很耗时很长的业务逻辑时使用，可以减小系统的响应时间，提高系统的吞吐率。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class UseFuture implements Callable<String> {
	
	private String para;
	
	public UseFuture(String para){
		this.para = para;
	}
	
	/**
	 * 这里真是的业务逻辑，其执行可能个很慢
	 */
	
	@Override
	public String call() throws Exception {
		
		//模拟执行耗时
		Thread.sleep(5000);
		String result = this.para + "处理完成~";
		
		return result;
	}

	//主控制函数
	public static void main(String args[]) throws InterruptedException, ExecutionException{
		String queryStr = "query";
		//构造FutureTask,并且传入需要真正进行业务逻辑处理的类，该类一定事先Callable接口的类
		FutureTask<String> futureTask1 = new FutureTask<>(new UseFuture(queryStr));
		FutureTask<String> futureTask2 = new FutureTask<>(new UseFuture(queryStr));

		//创建一个固定线程的线程池线程数为2
		ExecutorService executor = Executors.newFixedThreadPool(2);
		
		//这里日交任务future，则开启线程执行RealData的call()方法执行
		Future f1 = executor.submit(futureTask1);
		Future f2 = executor.submit(futureTask2);
		System.out.println("请求完毕");
		System.out.println(f1.get());
		System.out.println(f2.get());
		try {
			System.out.println("处理实际的业务逻辑...");
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println("数据：" + futureTask1.get());
		System.out.println("数据：" + futureTask2.get());
		
		executor.shutdown();
		
	}
}

输出结果：

请求完毕
null
null
处理实际的业务逻辑...
数据：query处理完成~
数据：query处理完成~