java中的并发工具类

最新推荐文章于 2022-09-04 16:36:26 发布

想你的夜713

最新推荐文章于 2022-09-04 16:36:26 发布

阅读量248

点赞数

分类专栏： Thread

本文链接：https://blog.csdn.net/u010289197/article/details/59729962

版权

Thread 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

（1）等待多线程完成的CountDownLatch

1）定义：允许一个或者多个线程等待其他线程完操作。在jdk1.5后的并发包中提供了CountDownLatch也可以实现join的功能，并且比join的功能更多。

2）应用场景：我们需要解析一个Excel里多个sheet的数据，此时可以考虑使用多线程，每一个线程解析一个sheet里的数据，等到所有的sheet都解析完成之后，程序需要提示解析完成。

3）代码示例：

package com.zl.thread.concurrent;
import java.util.concurrent.CountDownLatch;
/**
 * @author fab
 * 
 */
public class CountDownLatchTest {
	static CountDownLatch countDownLatch = new CountDownLatch(2);
	/**
	 * @param args
	 */
	public static void main(String[] args) throws InterruptedException {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(1);
				countDownLatch.countDown();
				System.out.println(2);
				countDownLatch.countDown();
			}
		}).start();
		countDownLatch.wait();
		System.out.println(3);
	}
}

CountDownlach的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N。当我们调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变为零。由于countDown方法可以用在任何地方，所以这里说的N个点，可以是N个线程，也可以是1个线程里的N个执行步骤。用在多线程中只需要把这个CountDownLatch的引用传递到线程里即可。

如果在某个解析sheet的线程处理的比较慢，我们不可能让主线程一直等待，所以可以使用另外一个带指定时间的await方法—await(long time,TimeUnit unit),这个方法等待待定时间后，就会不在阻塞当前线程。

特别注意：计数器必须大于等于0，只有等于0时候，计数器就是零，调用await方法时不会阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数器的值。一个线程调用countDown方法happen—before，另一个线程调用await方法。

（2）同步屏障CyclicBarrier

1）定义:字面意思就是可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

2）应用场景：CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。比如，一个Excel保存了所有银行流水，每个sheet保存一个账号近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完成后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

3）代码示例：

package com.zl.thread.concurrent;
import java.util.Map.Entry;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
 * 银行流水处理服务类
 * 
 * @author fab
 */
public class BankWaterService implements Runnable {

	// 创建4个屏障，处理完之后执行当前类的run方法
	private CyclicBarrier cb = new CyclicBarrier(4, this);

	// 4个sheet所以启动4个线程
	private Executor executor = Executors.newFixedThreadPool(4);

	// 保存每一个sheet计算出来的银流结果
	private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<String, Integer>();

	private void count() {
		for (int i = 0; i < 4; i++) {

			executor.execute(new Runnable() {

				@Override
				public void run() {
					// TODO 计算当前sheet的银流数据，计算代码省了
					sheetBankWaterCount
							.put(Thread.currentThread().getName(), 1);
					// 银流计算完成，插入一个屏障
					try {
						cb.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (BrokenBarrierException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}

	}

	@Override
	public void run() {
		// TODO 汇总每一个sheet计算出来的结果
		int result = 0;
		for (Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {
			result += sheet.getValue();
		}
		// 计算结果输出
		sheetBankWaterCount.put("result", result);
		System.out.println(result);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BankWaterService bws = new BankWaterService();
		bws.count();
	}

}

使用线程池创建4个线程，分别计算没个sheet里的数据，每个sheet计算结果是1，再有BankWatrerService线程汇总4个计算的结果，其结果：

（3） CountDownLatch和CyclicBarrier的区别

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。

（4）并发控制线程数的Semaphore

1）定义：信号量（Semaphore）是用来控制同步访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。

2）应用场景：Semaphore可以用于做流量控制，特别是公用资源有限的应用场景，比如数据库连接。假如一个需求，要读取几万个文件的数据，因为都是IO密集型任务，我们可以启动几十个线程并发地读取，但是如果读到内存后，还需要存储到数据库中，而数据库的连接数只有10个，这时我们需要控制只有10个线程同时获取数据库连接保存数据，否则会报错无法获取数据库连接。这个时候就可以用Sepaphore来做流量控制。

代码示例：

package com.zl.thread.concurrent;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
 * @author fab
 * 
 */
public class SemaphoreTest {
	private static final int THREAD_COUNT = 30;

	private static ExecutorService threadPool = Executors
			.newFixedThreadPool(THREAD_COUNT);

	private static Semaphore semaphore = new Semaphore(10);

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		for (int i = 0; i < THREAD_COUNT; i++) {
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					try {
						semaphore.acquire();
						System.out.println("save data");
						semaphore.release();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
		threadPool.shutdown();
	}
}

在代码中，虽然只有30个线程在执行，但是只允许10个并发执行。Semaphore的构造方法Semaphore(int permits)接收一个整形的数字，表示可用的许可证数量。Semphore(10)表示允许10个线程获取许可证，也就是最大并发数是10。Semphore的用法也很简单，首先线程使用Semphore的acquire()方法获取一个许可证，使用完之后调用release方法归还许可证。其结果：

（5）线程间交换数据的Exchanger

1）定义：一个用于线程间协作的工具类。用于进行线程间的数据交换。它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据。

2）应用场景：Exchangeer可以用于遗传算法，在遗传算法中需要选出两个人作为交配对象，这时候会交换两个人的数据，并使用交叉规则得到2个交配结果。Exchanger可用于校对工作，比如我们需要将纸制银行流水通过人工的方式录入成电子银行流水，为了避免错误，采用AB岗两人进行录入，录入到Excel之后，系统需要加载这两个Excel，并对这两个Excel数据进行校对，看看是否录入一致。

3）代码示例：

package com.zl.thread.concurrent;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author fab
 * 
 */
public class ExchangerTest {
	private static final Exchanger<String> exgr = new Exchanger<String>();
	private static ExecutorService threadPool = Executors.newFixedThreadPool(2);

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		threadPool.execute(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub

				try {
					String A = "银行流水A";// A录入银行流水数据
					exgr.exchange(A);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});

		threadPool.execute(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				try {
					String B = "银行流水B";// B录入银行流水数据
					String A = exgr.exchange("B");
					System.out.println("A和B数据是否一致:" + A.equals(B) + ",A录入的是:"
							+ A + ",B录入的是:" + B);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		threadPool.shutdown();
	}
}

如果两个线程有一个没有执行exchange()方法，则会一直等待，如果担心有特殊情况发生，避免一致等待，可以使用exchange(V x,long timeout,TimeUnit unit)设置最大等待时长。运行结果：

想你的夜713

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java中的并发工具类

（1）等待多线程完成的CountDownLatch1）定义：允许一个或者多个线程等待其他线程完操作。在jdk1.5后的并发包中提供了CountDownLatch也可以实现join的功能，并且比join的功能更多。2）应用场景：我们需要解析一个Excel里多个sheet的数据，此时可以考虑使用多线程，每一个线程解析一个sheet里的数据，等到所有的sheet都解析完成之后
复制链接

扫一扫