《java多线程学习-java.util.concurrent详解》

执行框程序(Executor)：最常见的用法就是用Executors来构造相关的线程池；用CompletionService来分离生产任务和已经完成的任务，生产者 submit 执行的任务。使用者 take 已完成的任务，并按照完成这些任务的顺序处理它们的结果；Callable和Future接口到处都需要用到。

 

队列(Queue)：在使用生产者消费者模式的时候需要构建出满足自己自身系统需要的队列。

    同步器(Synchronizer)常见的有5种：

1. 信号量(Semaphore)用于限制可以访问某些资源（物理的或逻辑的）的线程数目；
2. 闭锁(CountDownLatch)是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用于在保持给定数目的 信号、事件或条件前阻塞执行。把信号量设置为1的时候就是一个闭锁的实现。
3. 关卡(CyclicBarrier)允许一个给定数量的成员多次集中在一个关卡点，然后在统一执行后面的操作，这在并行迭代算法中非常有用，能把一个问题拆分成一系列相互独立的子问题。
4. 交换器(Exchanger)是关卡的另一种形式，它提供了一个同步点，在这个同步点，一对线程可以交换数据。每个线程通过exchange()方法的入口提供数据给他的伙伴线程，并接收他的伙伴线程提供的数据，并返回。它在多流水线设计中是有用的。
5. Future和FutureTask：可取消的异步计算，利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法。FutureTask可以通过线程池来执行。

    并发容器：ConcurrentHashMap来获取的完全并发和更新的所期望可调整并发的哈希表；期望的读数和遍历远远大于列表的更新数时，请使用CopyOnWriteArrayList 代替 ArrayList。

    原子操作(atomic)：支持在单个变量上解除锁的线程安全编程；我用的最多的是在多线程中的计数操作。

    互斥锁(Lock)：为锁和等待条件提供一个框架的接口和类，它不同于内置同步和监视器，该框架允许更灵活地使用锁和条件。

    Amdahl定律

    Amdahl定律描述了在一个系统中，基于可并行化和串行化的组件各自所占的比重，程序通过获得额外的计算资源，理论上能够加速多少。如果F是必须串行化执行的比重，那么Amdahl定律告诉我们，在一个N处理器的机器中，我们最多可以加速：1/(F+(1-F)/N) 。
    当N无限增大趋近无穷时，speedup的最大值无限趋近1/F，这意味着一个程序中如果50%的处理都需要串行进行的话，speedup只能提升2倍（不考虑事实上有多少线程可用）；如果程序的10%需要串行进行，speedup最多能够提高近10倍。更多信息点击这里

    Spring中的多线程任务

    在中小型项目中把一些提醒类邮件（邮件发送等级较低）放到spring线程池内执行，可以减少邮件发送等待时间。前提是：这些邮件的发送不需要放到数据库或者是文件系统中持久化。在邮件发送类中引用：TaskExecutor接口来执行邮件发送的线程，spring的配置使用示例：

 

(一) Latch/Barrier

 

1. CountDownLatch
    我们先来学习一下JDK1.5 API中关于这个类的详细介绍：
“一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。”

    这就是说，CountDownLatch可以用来管理一组相关的线程执行，只需在主线程中调用CountDownLatch 的await方法（一直阻塞），让各个线程调用countDown方法。当所有的线程都只需完countDown了，await也顺利返回，不再阻塞了。在这样情况下尤其适用：将一个任务分成若干线程执行，等到所有线程执行完，再进行汇总处理。

    下面我举一个非常简单的例子。假设我们要打印1-100，最后再输出“Ok“。1-100的打印顺序不要求统一，只需保证“Ok“是在最后出现即可。

    解决方案：我们定义一个CountDownLatch，然后开10个线程分别打印（n-1）*10+1至（n-1）*10+10。主线程中调用await方法等待所有线程的执行完毕，每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。

import java.util.concurrent.CountDownLatch;
/**
 * 示例：CountDownLatch的使用举例
 * Mail: [e-mail]
 * @author janeky
 */
public class TestCountDownLatch {
	private static final int N = 10;

	public static void main(String[] args) throws InterruptedException {
		CountDownLatch doneSignal = new CountDownLatch(N);
		CountDownLatch startSignal = new CountDownLatch(1);//开始执行信号

		for (int i = 1; i <= N; i++) {
			new Thread(new Worker(i, doneSignal, startSignal)).start();//线程启动了
		}
		System.out.println("begin------------");
		startSignal.countDown();//开始执行啦
		doneSignal.await();//等待所有的线程执行完毕
		System.out.println("Ok");

	}

	static class Worker implements Runnable {
		private final CountDownLatch doneSignal;
		private final CountDownLatch startSignal;
		private int beginIndex;

		Worker(int beginIndex, CountDownLatch doneSignal,
				CountDownLatch startSignal) {
			this.startSignal = startSignal;
			this.beginIndex = beginIndex;
			this.doneSignal = doneSignal;
		}

		public void run() {
			try {
				startSignal.await(); //等待开始执行信号的发布
				beginIndex = (beginIndex - 1) * 10 + 1;
				for (int i = beginIndex; i <= beginIndex + 10; i++) {
					System.out.println(i);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			} finally {
				doneSignal.countDown();
			}
		}
	}
}