重读Java并发编程艺术(7) -Java的并发工具类

最新推荐文章于 2024-08-20 11:07:00 发布

Qc_Hopkins

最新推荐文章于 2024-08-20 11:07:00 发布

阅读量120

点赞数

分类专栏： Java基础-重拾Java并发编程艺术文章标签： java 并发编程多线程

本文链接：https://blog.csdn.net/b_hopkins/article/details/109273920

版权

Java基础-重拾Java并发编程艺术专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. 计数器 CountDownLatch

1.1 介绍

1.1.1 构造函数

接受一个int类型的参数作为计数器，如果先等待N个任务完成，就传入N。

1.1.2 使用

CountDownLatch的await方法会阻塞当前线程，直到N变成零；
每调用一次 countDown 方法，N就会减1；
countDown方法可以用在任何地方，可以是在1个线程里的N个步骤，也可以是N个线程（需将该CountDownLatch对象的引用传入各个线程）。

1.1.3 注意

计数器必须大于等于0，计数器等于0时，调用await方法不会阻塞当前线程。
CountDownLatch不可能重新初始化或修改CountDownLatch对象的内部计数器的值。
一个线程调用countDown方法 happen-before，另一个线程调用 await 方法。

1.2 代码示例

public class CountDownLatchTest{
	//创建一个计数为2的计数器
	static CountDownLatch latch = new CountDownLatch(2);
	public static void main(String[] args) throws InterruptedException{
		//创建工作线程对象并开启线程
		new Thread(new Runnable(){
			@Override
			public void run(){
				System.out.println(1);
				latch.countDown();//计数器减1
				System.out.println(2);
				latch.countDown();//计数器减1
			}
		}).start();
		//当前线程调用await方法，阻塞等待计数器结束
		latch.await();
		System.out.println(3);
		//主线程等待计数器完成后再输出3，最后输出结果为 123
	}
}

2. 同步屏障CyclicBarrier

2.1 介绍

2.1.1 作用

让一组线程到达一个屏障（也叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续执行。

2.1.2 使用

构造方法接受一个int类型的参数，表示该屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier自身已经到达了屏障，然后该线程被阻塞。

2.2 代码示例

2.2.1 new CyclicBarrier(int)

public class CyclicBarrierTest{
	//创建一个拦截2个线程的同步屏障
	static CyclicBarrier cb = new CyclicBarrier(2);
	public static void main(String[] args){
		//子线程调用一次await
		new Thread(new Runnable(){
			@Override
			public void run(){
				try{
					cb.await();
				} catch(Exception e){}
				System.out.println(1);
			}
		}).start();
		//主线程调用一次await
		try{
			cb.await();
		} catch(Exception e){}
		System.out.println(2);
		//这里主线程和子线程并发执行，所以 12 和 21 两种输出结果都有可能
	}
}

如果这里把 new CyclicBarrier(2) 改成 new CyclicBarrier(3)，则主线程和子线程都会永远等待，因为没有第三个线程执行 await 方法。由于没有第三个线程到达屏障，所以之前到达屏障的两个线程都不会继续执行。

2.2.2 new CyclicBarrier(int, Runable)

用于在线程到达屏障时，优先执行 runnable。
可用于多个子线程计算子任务后，runnable入参做最后的合并计算场景。

public class CyclicBarrierTest{
	//创建一个拦截2个线程的同步屏障
	static CyclicBarrier cb = new CyclicBarrier(2, new BarrierAction());	
	public static void main(String[] args){
		//子线程调用一次await
		new Thread(new Runnable(){
			@Override
			public void run(){
				try{
					cb.await();
				} catch(Exception e){}
				System.out.println(1);
			}
		}).start();
		//主线程调用一次await
		try{
			cb.await();
		} catch(Exception e){}
		System.out.println(2);
	}
	//到达屏障后优先处理的Runable任务
	static class BarrierAction implements Runnable{
		@Override
		public void run(){
			System.out.println(3);
		}
	}
	//主线程和子线程都到达后，优先执行BarrierAction；
	//最后输出结果可能为 312 或 321
}

2.3 CyclicBarrier 和 CountDownLatch 的区别

CountDownLatch 的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数器，并让线程重新执行一次；
CyclicBarrier 的 getNumberWaitin 方法可以获得CyclicBarrier阻塞的线程数量；
CyclicBarrier 的 isBroken 方法用来了解阻塞的线程是否被中断。

3. 信号量 Semaphore

3.1 介绍

用于控制同时访问特定资源的线程数量，通过协调各个线程，保证合理的使用公共资源。

3.2 主要方法

构造方法 Semaphore(int permits) 接受一个整型的数字，表示可用的许可证数量；
使用 acquire 方法获取一个许可证；
使用 release 方法归还许可证；
也可使用 tryAcquire() 方法尝试获取许可证。

3.3 应用场景及代码示例

应用场景：流量控制，特别是公共资源有限的应用场景，如数据库连接。

假如有一个需求，要读取几万个文件的数据，由于都是IO密集型任务，可以启动几十个线程并发读取。但读到内存后，还需要存入数据库，而数据库连接数只有10个，这时需要控制只有10个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。

public class SemaphoreTest{
	//线程总数量
	private static final int THREAD_COUNT = 30;
	//创建线程池管理所有线程
	private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
	//创建10个许可证的信号量
	private static Semaphore s = new Semaphore(10);

	public static void main(String[] args){
		for(int i=0; i<THREAD_COUNT; i++){
			thradPool.execute(new Runnable(){
				@Override
				public void run(){
					try{
						s.acquire();//获取一个许可证
						System.out.println("save data")
						s.release();//归还许可证
					} catch(InterruptedException e){}
				}
			});
		}
		threadPool.shutdown();
	}
}

3.4 其他方法

int availablePermits(): 返回此信号量中当前可用的许可证数；
int getQueueLength(): 返回正在等待获取许可证的线程数；
boolean hasQueuedThreads(): 是否有线程正在等待获取许可证；
void reducePermits(int reduction): 减少reduction个许可证（protected方法）
Collection getQueuedThreads(): 返回所有等待获取许可证的线程集合（protected方法）

4. 交换者 Exchanger

4.1 介绍

用于进行线程间的数据交换，提供一个同步点，两个线程可以交换彼此的数据。
第一个线程先执行 exchange() 方法，一直等待第二个线程也执行 exchange 方法，当两个线程都到达同步点时，这两个线程就可以交换数据。

4.2 应用场景

可用于遗传算法，遗传算法需选出两个人作为交配对象，这时候会交换两人的数据，并用交叉规则得出两个交配结果。
可用于校对工作，一个线程可交换其他线程数据用于校验自身数据是否正确等逻辑。

4.3 代码示例

public class ExchangerTest{
	//创建一个交换String类型数据的交换者
	private static final Exchanger<String> exgr = new Exchanger<String>();
	//创建包含两个线程的线程池，管理需要交换数据的两个线程
	private static ExecutorService threadPool = Executors.newFixedThreadPool(2);
	
	public static void main(String[] args){
		//线程A的数据等待交换
		threadPool.execute(new Runnable(){
			@Override
			public void run(){
				try{
					String A = "线程A获取到的数据";
					exgr.exchange(A);
				} catch(InterruptedException e){}
			}
		});
		//线程B的数据等待交换，并且比较交换到的数据和自身是否一致
		threadPool.execute(new Runnable(){
			@Override
			public void run(){
				try{
					String B = "线程B获取到的数据";
					String A = exgr.exchange(B);
					System.out.println("判断A和B数据是否一致：" + A.equals(B) + "，A录入的是：" + A + "，B录入的是：" + B);
				} catch(InterruptedException B){}
			}
		});
		threadPool.shutdown();
	}
}