java中的并发工具类

CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

例1：

public class CountDownLatchTest {
	static CountDownLatch c = new CountDownLatch(2);

	public static void main(String[] args) throws InterruptedException {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(1);
				c.countDown();
				System.out.println(2);
				c.countDown();
			}
		}).start();
		c.await();
		System.out.println("3");
	}
}

调用c.await()时会阻塞主线程，直到c执行完count次countDown。

输出结果：

1

2

3

CountDownLatch底层内部实现了一个同步队列器，下面简单说明一下它的构造方法和两个核心方法。

1.构造方法 CountDownLatch(int count)

构造方法非常简单，就是创建一个内部类对象并初始化它的状态值为传入参数count。

2.countDown()：每次调用都将初始化的count值即内部类的状态值减1.

releaseShared(int arg)是同步队列器的模板方法，其关键是被重写的tryReleaseShared(releases);

tryReleaseShared(int releases)：这里的关键不在于返回值是true还是false，而是cas的将状态值c减1.

3.await():调用await()的线程会被阻塞，直到内部类的状态值变为0.

acquireSharedInterruptibly：tryAcquireShared方法返回值小于0，则需要独占式的获得同步状态（此时线程会被阻塞，直到同步状态变为0）

tryAcquireShared(int arg)

CyclicBarrier

例2：

public class CyclicBarrierTest {
	static CyclicBarrier c = new CyclicBarrier(2);

	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					c.await();
				} catch (Exception e) {
				}
				System.out.println(1);
			}
		}).start();
		try {
			c.await();
		} catch (Exception e) {
		}
		System.out.println(2);
	}
}

输出结果:

1

2

或者

2

1

核心方法：await()

Semaphore:

用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用公共资源，底层也是通过同步队列器实现。

public class SemaphoreTest {
	private static final int THREAD_COUNT = 30;
	private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
	private static Semaphore s = new Semaphore(10);

	public static void main(String[] args) {
		for (int i = 0; i < THREAD_COUNT; i++) {
			threadPool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						s.acquire();
						System.out.println("save data");
						s.release();
					} catch (InterruptedException e) {
					}
				}
			});
		}
		threadPool.shutdown();
	}
}

虽然线程池内最多可创建30个线程，但只有10个线程会并发执行。

Exchange：

用于进行线程间的数据交换。

public class ExchangerTest {
	private static final Exchanger<String> exgr = new Exchanger<String>();

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

	public static void main(String[] args) {
		threadPool.execute(new Runnable() {
			@Override
			public void run() {
				try {
					String A = "银行流水A"; // A录入银行流水数据
					exgr.exchange(A);
				} catch (InterruptedException e) {
				}
			}
		});
		threadPool.execute(new Runnable() {
			@Override
			public void run() {
				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) {
				}
			}
		});
		threadPool.shutdown();
	}
}