线程池与JUC强大辅助类

线程池

ThreadPoolExecutor

• 线程池状态
  ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量。

状态名	高三位
RUNNING（运行态）	111
SHUTDOWN（不会接收新任务，但会处理阻塞队列剩余任务）	000
STOP（会中断正在执行的任务，并抛弃阻塞队列任务）	001
TIDYING（任务全执行完毕，活动线程为 0 即将进入终结）	010
TERMINATED（终结状态）	011

从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING。

• 构造方法

public ThreadPoolExecutor(int corePoolSize,
	 int maximumPoolSize,
	 long keepAliveTime,
	 TimeUnit unit,
	 BlockingQueue<Runnable> workQueue,
	 ThreadFactory threadFactory,
	RejectedExecutionHandler handler);

参数名	说明
corePoolSize	核心线程数目 (最多保留的线程数)
maximumPoolSize	最大线程数目
keepAliveTime	生存时间 - 针对救急线程
unit	时间单位 - 针对救急线程
workQueue	阻塞队列
threadFactory	线程工厂 - 可以为线程创建时起个好名字
handler	拒绝策略

工作原理

• 线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。
• 当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue 队列排队，直到有空闲的线程。
• 如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线程来救急。
• 如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。
• 当高峰过去后，超过corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由keepAliveTime 和 unit 来控制。

线程池分类

根据构造方法，JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池。

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
	 return new ThreadPoolExecutor(nThreads, nThreads,
	 0L, TimeUnit.MILLISECONDS,
	 new LinkedBlockingQueue<Runnable>());
}

• 核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间。
• 阻塞队列是无界的，可以放任意数量的任务。

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
	 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
	 60L, TimeUnit.SECONDS,
	 new SynchronousQueue<Runnable>());
}

• 核心线程数是 0， 最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着全部都是救急线程（60s 后可以回收），救急线程可以无限创建。
• 队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）。

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
	 return new FinalizableDelegatedExecutorService
	 (new ThreadPoolExecutor(1, 1,
	 0L, TimeUnit.MILLISECONDS,
	 new LinkedBlockingQueue<Runnable>()));
}

• 线程个数始终为1，不能修改。
• 希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

提交任务

// 执行任务
void execute(Runnable command);

// 提交任务 task，用返回值 Future 获得任务执行结果
<T> Future<T> submit(Callable<T> task);

// 提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException;

// 提交 tasks 中所有任务，带超时时间
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException;

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
 throws InterruptedException, ExecutionException;
 
 // 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout, TimeUnit unit)
 throws InterruptedException, ExecutionException, TimeoutException;

关闭线程池

/*
线程池状态变为 SHUTDOWN
- 不会接收新任务
- 但已提交任务会执行完
- 此方法不会阻塞调用线程的执行
*/
void shutdown();

/*
线程池状态变为 STOP
- 不会接收新任务
- 会将队列中的任务返回
- 并用 interrupt 的方式中断正在执行的任务
*/
List<Runnable> shutdownNow();

// 不在 RUNNING 状态的线程池，此方法就返回 true
boolean isShutdown();
// 线程池状态是否是 TERMINATED
boolean isTerminated();
// 调用 shutdown 后，由于调用线程并不会等待所有任务运行结束，因此如果它想在线程池 TERMINATED 后做些事
情，可以利用此方法等待
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

任务调度线程池

在『任务调度线程池』功能加入之前，可以使用 java.util.Timer 来实现定时功能，Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。

public static void main(String[] args) {
 Timer timer = new Timer();
 TimerTask task1 = new TimerTask() {
	 @Override
	 public void run() {
		 log.debug("task 1");
		 sleep(2);
	  }
 };
 TimerTask task2 = new TimerTask() {
	 @Override
	 public void run() {
	 	log.debug("task 2");
	 }
 };
 // 使用 timer 添加两个任务，希望它们都在 1s 后执行
 // 但由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行
 timer.schedule(task1, 1000);
 timer.schedule(task2, 1000);
}

scheduleAtFixedRate：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
pool.scheduleAtFixedRate(() -> {
	 log.debug("running...");
}, 1, 1, TimeUnit.SECONDS);

scheduleWithFixedDelay：

ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
pool.scheduleWithFixedDelay(()-> {
	 log.debug("running...");
	 sleep(2);
}, 1, 1, TimeUnit.SECONDS);

Fork/Join

• Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算。
• Fork/Join 默认会创建与 cpu 核心数大小相同的线程池。
• 提交给 Fork/Join 线程池的任务需要继承 RecursiveTask（有返回值）或 RecursiveAction（没有返回值）。

class AddTask1 extends RecursiveTask<Integer> {
	 int n;
	 public AddTask1(int n) {
	 	this.n = n;
	 }
	 @Override
	 public String toString() {
	 	return "{" + n + '}';
	 }
	 @Override
	 protected Integer compute() {
		 // 如果 n 已经为 1，可以求得结果了
		 if (n == 1) {
		 log.debug("join() {}", n);
		 return n;
	 }
	 
	 // 将任务进行拆分(fork)
	 AddTask1 t1 = new AddTask1(n - 1);
	 t1.fork();
	 log.debug("fork() {} + {}", n, t1);
	 
	 // 合并(join)结果
	 int result = n + t1.join();
	 log.debug("join() {} + {} = {}", n, t1, result);
	 return result;
	 }
	 //测试
	 public static void main(String[] args) {
		 ForkJoinPool pool = new ForkJoinPool(4);
		 System.out.println(pool.invoke(new AddTask1(5)));
	}
}

J.U.C

AQS

全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架。

• 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁。
• 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList。
• 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet。

子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）

• tryAcquire，获取锁
• tryRelease，释放锁
• tryAcquireShared
• tryReleaseShared
• isHeldExclusively

设计原理

//获取锁
while(state 状态不允许获取) {
	 if(队列中还没有此线程) {
	 入队并阻塞
	 }
}
当前线程出队
//释放锁
if(state 状态允许了) {
 恢复阻塞的线程(s)
}

• state 设计
  state 使用 volatile 配合 cas 保证其修改时的原子性；
  state 使用了 32bit int 来维护同步状态，因为当时使用 long 在很多平台下测试的结果并不理想；
• 阻塞恢复设计
  解决方法是使用 park & unpark 来实现线程的暂停和恢复，先 unpark 再 park 也没问题；
  park & unpark 是针对线程的，而不是针对同步器的，因此控制粒度更为精细；
  park 线程还可以通过 interrupt 打断；
• 队列设计
  使用了 FIFO 先入先出队列，并不支持优先级队列
  设计时借鉴了 CLH 队列，它是一种单向无锁队列

ReentrantReadWriteLock

当读操作远远高于写操作时，这时候使用 读写锁 让 读-读 可以并发，提高性能。

class DataContainer {
	private Object data;
    private ReentrantReadWriteLock rw=new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock r=rw.readLock();
    private ReentrantReadWriteLock.WriteLock w=rw.writeLock();
    
    Object read() throws InterruptedException {
		try {
			System.out.println("获取读锁...");
			r.lock();
			System.out.println("读取数据...");
			Thread.sleep(1000);
			return data;
		} finally {
			System.out.println("释放读锁...");
			r.unlock();
		}
	}
    
    void write() throws InterruptedException {
		try {
			System.out.println("获取写锁...");
			w.lock();
			System.out.println("写入数据...");
			Thread.sleep(1000);
		} finally {
			System.out.println("释放读锁...");
			w.unlock();
		}
	}
}

public class ReentrantReadWriteLockDemo {
     public static void main(String[] args) throws InterruptedException {
    	 DataContainer dataContainer = new DataContainer();
    	 new Thread(() -> {
    	  try {
			dataContainer.read();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	 }, "t1").start();
    	 Thread.sleep(1000);
    	 new Thread(() -> {
    	  try {
			dataContainer.write();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	 }, "t2").start();


	}
}

StampedLock

该类自 JDK 8 加入，是为了进一步优化读性能，它的特点是在使用读锁、写锁时都必须配合【戳】使用加解读锁。

private final StampedLock lock = new StampedLock();
//加读锁
long stamp = lock.readLock();
//释放锁
lock.unlockRead(stamp);

//加写锁
long stamp = lock.writeLock();
//解锁
lock.unlockWrite(stamp);

Semaphore

信号量，用来限制能同时访问共享资源的线程上限。

public class SemaphoreDemo {
	
	public static void main(String[] args) {
		Semaphore semaphore=new Semaphore(3);
		// 2. 10个线程同时运行
		 for (int i = 0; i < 10; i++) {
		 new Thread(() -> {
		 // 3. 获取许可
		 try {
		    semaphore.acquire();
		 } catch (InterruptedException e) {
		    e.printStackTrace();
		 }
		 try {
		   System.out.println("running...");
           Thread.sleep(1000);
		   System.out.println("end...");
		 } catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
		   // 4. 释放许可
		   semaphore.release();
		}}).start();
	}
  }

}

CountdownLatch

用来进行线程同步协作，等待所有线程完成倒计时。
其中构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一。

public class CountdownLatchDemo {
	
	public static void main(String[] args) throws InterruptedException {
		CountDownLatch countDownLatch=new CountDownLatch(2);
		new Thread(()->{
			countDownLatch.countDown();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(countDownLatch.getCount());
		}).start();
		new Thread(()->{
			countDownLatch.countDown();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(countDownLatch.getCount());
		}).start();
		System.out.println("await...");
		countDownLatch.await();
		System.out.println("end......");
	}

}

CyclicBarrier

循环栅栏，用来进行线程协作，等待线程满足某个计数。构造时设置『计数个数』，每个线程执行到某个需要“同步”的时刻调用 await() 方法进行等待，当等待的线程数满足『计数个数』时，继续执行。

public class CyclicBarrierDemo {
     public static void main(String[] args) {
    	 CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
    	 new Thread(()->{
    	  System.out.println("线程1开始.."+new Date());
    	  try {
    	  	cb.await(); // 当个数不足时，等待
    	  } catch (InterruptedException | BrokenBarrierException e) {
    	  	e.printStackTrace();
    	  }
    	  System.out.println("线程1继续向下运行..."+new Date());
    	 }).start();
    	 new Thread(()->{
    	  System.out.println("线程2开始.."+new Date());
    	  try { 
    	  Thread.sleep(2000); 
    	  } catch (InterruptedException e) { }
    	  try {
    	  	cb.await(); // 2 秒后，线程个数够2，继续运行
    	  } catch (InterruptedException | BrokenBarrierException e) {
    	  	e.printStackTrace();
    	  }
    	  System.out.println("线程2继续向下运行..."+new Date());
    	 }).start();
	}
}

线程安全集合类

线程安全集合类可以分为三大类：

• 遗留的线程安全集合如 Hashtable ， Vector。
• 使用 Collections 装饰的线程安全集合，如：
  Collections.synchronizedCollection
  Collections.synchronizedList
  Collections.synchronizedMap
  Collections.synchronizedSet
  Collections.synchronizedNavigableMap
  Collections.synchronizedNavigableSet
  Collections.synchronizedSortedMap
  Collections.synchronizedSortedSet
• java.util.concurrent.*下的线程安全集合类：
  Blocking 大部分实现基于锁，并提供用来阻塞的方法
  CopyOnWrite 之类容器修改开销相对较重
  Concurrent 类型的容器