Java多线程基础知识（五）

一. Java中的13个原子操作类

在Jdk1.5中，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全的更新一个变量的方式。

1. 原子更新基本类型类

AtomicBoolean ： 原子更新布尔类型

AtomicInteger ： 原子更新整型

AtomicLong ： 原子更新长整型

2. 原子更新数组

AtomicIntegerArray： 原子更新整型数组里的元素

AtomicLongArray：原子更新长整型数组里的元素

AtomicReferenceArray：原子更新引用类型数组里的元素

3. 原子更新引用类型

AtomicReference：原子更新引用类型

AtomicReferenceFieldUpdater：原子更新引用类型里的字段

AtomicMarkableReference：原子更新带有标记的引用类型

4. 原子更新字段类

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器

AtomicLongFieldUpdater：原子更新长整型字段的更新器

AtomicStampedReference：原子更新带有版本号的引用类型

二. Java中的并发工具类

在Jdk1.5中，提供了几个非常有用的并发工具类，它们提供了一种并发流程控制手段。

1. CountDownLatch 等待多个线程完成

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

package com.bochao.concurrency;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
	
	static CountDownLatch countDownLatch = new CountDownLatch(2);
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				
				System.out.println(1);
				try {
					Thread.currentThread().sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				countDownLatch.countDown();
				
				System.out.println(2);
				countDownLatch.countDown();
			}
		}).start();
		
		
		try {
			countDownLatch.await();
			System.out.println(3);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

}

2. CyclicBarrier 同步屏障

让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

package com.bochao.concurrency;

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

class A implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("之前触发的动作!");
	}
}

public class CyclicBarrierTest2 {
	
	static CyclicBarrier c = new CyclicBarrier(2, new A());
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				try {
					c.await();
				} catch (InterruptedException | BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(1);
			}
		}).start();
		
		try {
			c.await();
		} catch (InterruptedException | BrokenBarrierException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(2);
	}
	
}

CyclicBarrier应用场景

它多应用于使用多线程计算数据的场景，最后使用前置的主线程任务来统计合并计算结果。

CyclicBarrier 和 CountDownLatch的区别

1. CountDownLatch 的计数器只能使用一次

2. CyclicBarrier计数器可以使用reset()重置

3. Semaphore 控制并发线程数

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

package com.bochao.concurrency;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;


public class SemaphoreTest {
	
	private static final int THREAD_COUNT = 20;
	
	// 创建固定大小的20个线程池
	private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
	
	// 信号量10个， 只允许并发执行10个线程
	private static Semaphore semaphore = 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 {
						// 获取执行许可
						semaphore.acquire();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("指定特定代码!");
					semaphore.release();
				}
			});
		}
		
		threadPool.shutdown();
	}

}

一些比较有用的方法：

<1>. int availablePermits() ：返回此信号量中当前可用的许可证数

<2>. int getQueueLength() ：返回正在等待获取许可证的线程数

<3>. boolean hasQueuedThreads()：是否有线程正在等待获取许可证

<4>. void reducePermits(int reduction)：减少reduction个许可证，是个protected方法

<5>. Collection getQueuedThreads() ：返回所有等待获取许可证线程集合，是个protected方法

4. Exchanger 线程间交换数据

Exchanger是一个用于线程间协作的工具类。可用于线程间的数据交换，它提供一个同步点，在这个同步点，两个线程可以交换彼此数据，这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方线程。

package com.bochao.concurrency;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

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() {
				
				String A = "A";
				
				try {
					exgr.exchange(A);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		
		threadPool.execute(new Runnable() {
			
			@Override
			public void run() {
				
				String B = "B";
				try {
					String A = exgr.exchange(B);
					System.out.println("A录入数据：" + A);
					System.out.println("B录入数据：" + B);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
	}
	

}