重读Java并发编程艺术(5) - 并发容器和框架

1. ConcurrentHashMap

1.1 优点

• HashMap代替线程不安全
• HashTable效率低下（synchronized）
• ConcurrentHashMap锁分段技术可有效提升并发访问率

1.2 结构

• ConcurrentHashMap
  • Segment (分段锁，可重入锁，类似HashMap的数组和链表结构)
    • HashEntry（链表结构元素）

一个ConcurrentHashMap中包含一个Segment数组，每个Segment数组包含一个HashEntry数组，每个HashEntry是一个链表结构的元素。
当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁。

1.3 操作

1.3.1 get操作

• 先经过一次再散列，用这个散列值通过散列运算定位到Segment，再通过散列算法定位到元素。
• get操作不需要加锁，通过将共享变量（如统计当前Segment大小的count字段和HashEntry的value）定义成volatile类型实现。支持多线程读和单线程写（写入值不依赖原值时支持多线程写）。

1.3.2 put操作

1.3.2.1 过程

• 需要加锁，先定位到Segment，在Segment中进行插入操作。
• 插入操作包括两个步骤：
  • 判断 Segment 中 HashEntry 是否需要扩容；
  • 定位添加元素的位置并添加到HashEntry数组中。

1.3.2.2 扩容

• 通过HashEntry 数组大小是否超过阈值判断是否扩容。Segment 扩容比 HashMap 更恰当，HashMap 是插入后判断的，有可能扩容后不再有新元素插入，这时HashMap就进行了一次无效的扩容。
• 扩容过程：创建一个两倍原来容量的数组，将原数组元素再散列后插入新的数组里。
• ConcurrentHashMap 不会对整个容器进行扩容，而只对某个Segment进行扩容。

1.3.3 size操作

先尝试2次不加锁方式统计各个Segment大小之和，如果统计过程中，容器的count发生了变化，则再采用加锁的方式来统计所有Segment大小之和。

判断统计的时候容器是否发生变化：在put、remove 和 clean 方法里操作元素前都会将变量 modCount 进行加1， 故可以统计size前后比较 modCount 是否发生变化。

2. 线程安全队列

2.1 线程安全队列实现方式：

• 阻塞方式：一个锁（入队出队用同一把锁）或两个锁（入队出队用不同的锁）
• 非阻塞方式：循环CAS实现

2.2 ConcurrentLinkedQueue

2.2.1 特点

非阻塞，基于链接节点的无界线程安全队列，采用先进先出规则对节点排序，添加元素时加到队列尾部，取出元素时返回队列头部元素。采用"wait-free"算法（即CAS）。

2.2.2 结构

• ConcurrentLinkedQueue 由 head 节点和 tail 节点组成；
• 每个节点（Node）由节点元素 item 和指向下一个节点的应用 next 组成；
• 默认情况 head 节点存储的元素为空，tail 节点等于 head 节点。
  

2.2.3 入队

2.2.3.1 入队过程

将入队节点添加到队列尾部。

• 将入队节点设置成当前队列尾节点的下一个节点；
• 更新 tail 节点：
  • 如果 tail 节点的 next 节点为空，设置 tail 节点的 next 为入队节点；
  • 如果tail节点的next节点不为空，设置 tail 节点为入队节点。

（所以 tail 节点不总是尾节点）

2.2.3.2 HOPS设计意图

为什么不让 tail 永远指向队列尾节点？

• 为了避免每次都使用循环CAS更新 tail 节点，提高效率。
• 当 tail 节点和尾节点的距离大于等于常量 HOPS（默认为1）时才更新 tail 节点。

（用定位尾节点操作代替每次更新 tail 节点，本质上是通过增加对 volatile 变量的读操作来减少对 volatile 变量的写操作）
注意：入队方法永远返回 true，故不要通过返回值判断入队是否成功。

2.2.4 出队

不是每次出队都更新 head 节点，

• 当 head 节点里有元素时，直接弹出 head 节点里的元素；
• 当 head 节点里没有元素时，出队操作才会更新 head 节点。
  （同样是通过 hops 变量减少使用 CAS 更新 head 节点的消耗）

2.3 阻塞队列 BlockingQueue

2.3.1 概念

一个支持两个附加操作的队列：

• 支持阻塞的插入方法：当队列满时，队列阻塞插入元素的线程，直到队列不满。
• 支持阻塞的移除方法：队列为空时，获取元素的线程会等待队列变为非空。

2.3.2 应用场景

• 常用于生产者和消费者的场景

2.3.3 插入移除操作的4种处理方式

方法/处理方式	抛出异常	返回特殊值	一直阻塞	超时退出
插入方法	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除方法	remove()	poll()	take()	poll(time, unit)
检查方法	element()	peek()	不可用	不可用

• 抛出异常：
  • 队列满时，插入元素抛出 IllegalStateException(“Queue full”) 异常；
  • 队列空时，取出元素抛出 NoSuchElementException 异常；
• 返回特殊值：
  • 插入元素时，返回元素是否插入成功，成功返回true；
  • 移除元素时，从队列里取出一个元素，没有则返回null；
• 一直阻塞：
  • 队列满时，生产者线程 put 元素，队列会一直阻塞生产者线程，直到队列可用或响应中断退出。
  • 队列空时，消费者线程 take 元素，队列会阻塞消费者线程，直到队列不为空；
• 超时退出：
  • 当队列满时，生产者线程插入元素会阻塞生产者线程一段时间，超过指定时间，生产者线程就退出；
  • 当队列空时，消费者线程取出元素会阻塞消费者线程一段时间，超过指定时间，返回null。

若是无界阻塞队列则不可能出现队列满的情况，所以使用put或offer方法永远不会被阻塞，且offer方法永远返回true。

2.3.4 Java阻塞队列

1. ArrayBlockingQueue: 一个由数组结构组成的有界阻塞队列；
2. LinkedBlockingQueue: 一个由链表结构组成的有界阻塞队列；
3. PriorityBlockingQueue: 一个支持优先级排序的无界阻塞队列；
4. DelayQueue: 一个使用优先级队列实现的无界阻塞队列；
5. SynchronousQueue: 一个不存储元素的阻塞队列；
6. LinkedTransferQueue: 一个由链表结构组成的无界阻塞队列；
7. LinkedBlockingDeque: 一个由链表结构组成的双向阻塞队列。

2.3.4.1 ArrayBlockingQueue

有界，默认非公平（保证公平性会降低吞吐量），其使用可重入锁实现公平性：

public ArrayBlockingQueue(int capacity, boolean fair){
   if (capacity <= 0) throw new IllegalArgumentException();
   this.items = new Object[capacity];
   lock = new ReentrantLock(fair);
   notEmpty = lock.newCondition();
   notFull = lock.newCondition();
}

2.3.4.2 LinkedBlockingQueue

有界，默认和最大长度为 Integer.MAX_VALUE。

2.3.4.3 PriorityBlockingQueue

无界，默认使用自然顺序升序排列，也可以自定义类实现 compareTo() 方法来指定元素排序规则，或者初始化时指定构造参数 Comparator 来排序，不能保证同优先级元素的顺序。

2.3.4.4 DelayQueue

2.3.4.4.1 特点

无界，支持延时获取元素，使用PriorityQueue 实现，元素必须实现 Delayed 接口， 创建元素时可指定多久才能从队列种获取当前元素。

2.3.4.4.2 应用场景

• 缓存系统设计：使用 DelayQueue 保存缓存元素的有效期，使用一个线程循环查询 DelayQueue， 一旦能从 DelayQueue 中获取元素时，表示缓存有效期到了。
• 定时任务调度：使用 DelayQueue 保存当天将会执行的任务和执行时间，一旦从 DelayQueue 中获取到任务就开始执行， 比如 TimeQueue 就是使用 DelayQueue 实现的。

2.3.4.4.3 实现Delay接口

参考 ScheduledThreadPoolExecutor 里 ScheduledFutureTask 类的实现，分三步：

1. 对象创建时初始化基本数据，用time记录延时时间，用sequenceNumber标识元素在队列中的先后顺序；
2. 实现 getDelay 方法，返回当前元素还需要延时多长时间，单位是纳秒 , time小于当前时间时返回负数

public long getDelay(TimeUnit unit){
	//调用时可指定任意单位
	return unit.convert(time-now(), TimeUnit.NANOSECONDS);
}

3. 实现 compareTo 方法来指定元素的顺序，如让延时时间最长的放在队列末尾。

2.3.4.4.4 实现延时阻塞队列

long delay = first.getDelay(TimeUnit.NANOSECONDS);
if(delay<=0)
	return q.poll();
else if(leader != null)
	//leader是一个等待获取队列头部元素的线程，不为空则表示已经有线程在等待获取头部元素
	available.await();
else {
	Thread thisThread = Thread.currentThread();
	leader = thisThread;
	try{
		available.awaitNanos(delay);
	}finally{
		if(leader == thisThread)
			leader = null;
	}
}

2.3.4.5 SynchronousQueue

不存储元素，每一个put操作必须等待一个take操作，否则不能继续添加元素。
支持公平访问队列，默认非公平。
适合传递性场景，吞吐量高于 LinkedBlockingQueue 和 ArrayBlockingQueue。

2.3.4.6 LinkedTransferQueue

无界，比其他阻塞队列多了 tryTransfer 和 transfer 方法。

2.3.4.6.1 transfer 方法

• 如果当前有消费者正在等待接收元素（使用take()或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立即传输给消费者；
• 如果没有消费者正在等待接收元素，transfer方法会将元素存放至队列的tail节点，并等到该元素被消费者消费了才返回。

2.3.4.6.2 tryTransfer 方法

试探生产者传入元素是否能直接传给消费者。立即返回true/false，不等待。

2.3.4.6.3 带超时时间的 tryTransfer 方法

试图将生产者传入的元素直接传给消费者，没有被消费则等待指定的时间再返回。

2.3.4.7 LinkedBlockingDeque

双向队列，两端均可插入和移出元素。可应用在“工作窃取”模式中。
因为多了一个入口，在多线程同时入队时，减少了一半竞争。
比起其他阻塞队列，多了 addFirst、addLast、offerFirst、offerLast、peekFirst、peekLast方法。
初始化时可设置容量防止其过度膨胀

2.3.5 阻塞队列实现原理

JDK使用通知模式实现，如ArrayBlockingQueue使用Condition实现。

• 队列满时生产者添加元素会阻塞生产者；
• 消费者消费一个元素后，会通知生产者当前队列可用。

3. Fork/Join 框架

3.1 概念

Java 7 提供的一个用于并行执行任务的框架。

• Fork: 将一个大任务切分为若干子任务并行的执行；
• Join: 合并这些子任务的执行结果，最后得到这个大任务的结果。

3.2 工作窃取算法(work-stealing)

3.2.1 介绍

多个线程执行子任务时，先执行完的线程可以去其他线程的队列里窃取一个子任务来执行。这时这两个线程访问同一队列，为了减少竞争，通常使用双端队列，被窃取任务线程永远从头部拿任务执行，窃取任务的线程永远从双端队列的尾部拿任务执行。

3.2.1 优缺点

• 优点：充分利用线程进行并行计算，减少线程间竞争。
• 缺点：
  • 某些情况还是存在竞争（如双端队列里只有一个任务时）；
  • 消耗更多的系统资源（如创建多个线程和多个双端队列）。

3.3 Fork/Join框架设计及实现

3.3.1 设计

两个步骤：

1. 分割任务: fork类负责将大任务分割成子任务，对子任务继续分割直到子任务足够小。
2. 执行任务并合并结果: 分割的子任务分别放在双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果统一放在一个队列里，启动一个线程从队列里拿数据合并。

3.3.2 类

Fork/Join框架使用两个类来完成这两个步骤：

• ForkJoinTask: 任务类，使用时一般继承其两个子类：
  • RecursiveAction: 用于没有返回结果的任务。
  • RecursiveTask: 用于有返回结果的任务。
• ForkJoinPool: 用来执行ForkJoinTask。
  任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列头部。
  当一个工作线程的队列里暂时没有任务时，会随机从其他工作线程的队列尾部获取一个任务。

3.2.3 实现原理

ForkJoinPool 由 ForkJoinTask 数组和 ForkJoinWorkerThread 数组组成。

3.2.3.1 ForkJoinTask的fork方法实现原理

• 调用ForkJoinWorkerThread的pushTask方法异步执行这个任务，然后立即返回结果。
• pushTask方法把当前任务存放在ForkJoinTask数组队列里，然后调用ForkJoinPool的signalWork()方法唤醒或创建一个工作线程来执行任务。

3.2.3.2 ForkJoinTask的fork方法实现原理

调用doJoin方法得到当前任务状态，判断返回什么结果。

• 如果任务状态为执行完成，则直接返回任务状态；
• 如果没有执行完成，则从任务数组中取出任务并执行；
  • 如果顺利执行完成，则设置任务状态为 NORMAL；
  • 如果出现异常，则记录异常并设置任务状态为 EXCEPTIONAL。

3.2.4 Fork/join框架的异常处理

ForkJoinTask执行时可能抛异常，由于没办法在主线程里直接捕获异常，所以提供了以下方法：

• isCompletedAbnormally() 检查任务是否已经抛出异常或取消。
• getException() 方法，返回Throwable对象，
  • 如果任务被取消则返回CancellationException；
  • 如果任务没有完成或没有抛出异常则返回null。

3.3 应用示例

需求：计算 1+2+3+4 的结果。
思路：

• 考虑如何分割：如果希望每个子任务最多执行两个数相加，那么应设置阈值为2；那么Fork/Join框架会将这个任务fork成两个子任务，分别计算1+2和3+4，再join两者的结果。
• 因为是有结果的任务，所以必须继承 RecursiveTask。

代码示例：

package test;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class CountTask extends RecursiveTask<Integer>{
	private static final int THRESHOLD = 2;//阈值
	private int start;
	private inte end;

	public CountTask(int start, int end){
		this.start = start;
		this.end = end;
	}
	
	//实现compute方法来处理任务
	@Override
	public Integer compute() {
		int sum = 0;
		//如果任务足够小就计算任务
		boolean canCompute = (end-start) <= THRESHOLD;
		if(canCompute){
			for(int i=start; i<=end; i++){
				sum += i;
			}
		} else {
			//如果任务大于阈值，就分裂成两个子任务计算
			int middle = (start + end) / 2;
			CountTask leftTask = new CountTask(start, middle);
			CountTask rightTask = new CountTask(middle+1, end);
			//执行子任务
			leftTask.fork();
			rightTask.fork();
			//等待子任务执行完，并得到其结果
			int leftResult = leftTask.join();
			int rightResult = rightTask.join();
			//合并子任务
			sum = leftResult + rightResult;
		}
		return sum;
	}

	public static void main(String[] args){
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		//生成一个计算任务，负责计算 1+2+3+4
		CountTask task = new CountTask(1, 4);
		//执行一个任务
		Future<Integer> result = forkJoinPool.submit(task);
		try{
			System.out.println(result.get());
		}catch(InterruptedException e){
		}catch(ExecutionExceptio e){
		}
	}
}