读书笔记（四）：并发

Java的13个原子操作类：

而Java从JDK 1.5开始提供了java.util.concurrent.atomic包(以下简称Atomic包)，这个包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原于更新数组、原子更新引用(引用类型,是指除了基本的变量类型之外的所有类型（如通过 class 定义的类型）)和原子更新属性(字段)。Atomic包里的类基本都是使用Unsafe实现的包装类。

1. 原子更新基本类型类：

使用原子的方式更新基本类型，Atomic包提供了以下3个类：

• AtomicBoolean:原子更新布尔类型。
• AtomicInteger:原子更新整型。
•  AtomicLong：原子更新长整型。

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

• int addAndGet (int delta)：以原子方式将输入的数值与实例中的值(AtomicInteger里的value)相加，并返回结果。
• boolean compareAndSet (int expect, int update):如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
• int getAndIncrement：以原子方式将当前值加1，注意，这里返回的是自增前的值。
• void lazySet (int newValue):最终会设置成newValue，使用lazySet设置值后，可能是致其他线程在之后的一小段时间内还是可以读到旧的值。
• int getAndSet (int newValue):以原子方式设置为newValue的值，并返回旧值。

2.原子更新数组：

通过原子的方式更新数组里的某个元素，Atomic包提供了以下4个类：

1. AtomicIntegerArray：原子更新整型数组里的元素。
2. AtomicLongArray：原子更新长整型数组里的元素。
3. AtomicReferenceArray:原子更新引用类型数组里的元素。
4. AtomicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法如下。int addAndGet (int i, int delta):以原子方式将输入值与数组中索引i的元素相加。boolean compareAndSet (int i, int expect, int update):如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。注意：一个数组通过AtomicIntegerArray的构造方法传递进去，AtomicIntegerArray会将数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。

3.原子更新引用类型：

原子更新基本类型的AtomicInteger，只能更新一个变量。如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类：

• AtomicReference:原子更新引用类型。
• AtomicReferenceFieldUpdater:原子更新引用类型里的字段。
• AtomicMarkableReference:原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。

4.原子更新字段类：

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类，Atomic包提供了以下3个类进行原子字段更新：

• AtomicIntegerFieldUpdater:原子更新整型的字段的更新器。
• AtomicLongFieldUpdater:原子更新长整型字段的更新器。
• AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。

要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新类的字段(属性)必须使用public volatile修饰符。

Java中的并发工具类：

在JDK的并发包里提供了几个非常有用的并发工具类。CounmDownLatch、CyclicBarrier和Somaphore工具类提供了一种并发流程控制的手段，Exchanger工具类则提供了在线程间数据的一种手段。

等待多线程完成的CountDownLatch：

CountDownLatch允许一个或多个线程等待其他线程完成操作。假如有这样一个需求：我们需要解析一个Excel里多个sheet的数据，此时可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完成。这种情况下可以使用join或者CountDownLatch。

CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N。当我们调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变成零。由于countDown方法可以用在任何地方，所以这里说的N个点，可以是N个线程，也可以是1个线程里的N个执行步骤。用在多个线程时，只需要把这个CountDownLatch的引用传递到线程里即可。如果有某个解析sheet的线程处理得比较慢，我们不可能让主线程一直等待，所以可以使用另外一个带指定时间的await方法——await (long time, TimeUnit unit)，这个方法等待特定时间后，就会不再阻塞当前线程。

注意 计数器必须大于等于0，只是等于0时候，计数器就是零，调用await方法时不会阻塞当前线程。CountDownLatch不可能重新初始化或者修改CountDownLatch对象的内部计数器的值。

同步屏障CyclicBarrier：

 CyclicBarrier的字面意思是可循环使用(Cyelic)的屏障(Barrier)。 它要做的事情是，让一组线程到达一个屏障(也可以叫同步点)时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。其中： CyclicBarrier默认的构造方法是 CyclicBarrier(int parties),其参数就表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier我已经到达了屏障，然后当前线程就会被阻塞。 CyclicBarrier还提供一个更加高级的构造函数 CyclicBarrier(int parties,Runnable barrierAction)，用于在线程到达屏障时，优先执行barrierAction，方便处理更加复杂的业务场景。 CyclicBarrier还可以用于多线程计算数据，最后合并计算结果的场景。

CyclicBarrier和CountDownLatch的区别：

CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场景。例如，如果计算发生错误，可以重置计数器，并让线程重新执行一次。CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarier阻塞的线程数量。isBroken()方法用来了解阻塞的线程是否被中断。

控制并发线程数的Semaphore：

semaphore是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。可以把它比作控制流量的红绿灯，只允许特定数量的车辆行驶在路上，除非有车辆离开了。应用场景可以是用于流量控制，特别是公共资源有限的。Semaphare的构造方法 Semaphore (int permits)接受一个整型的数字，表示可用的许可证数量。Semaphore(10)表示允许10个线程获取许可证，也就是最大并发数是10。Semaphore的用法也很简单，首先线程使用Semaphore的acquire(）方法获取一个许可证，使用完之后调用release()方法归还许可证。还可以用tryAcquire()方法尝试获取许可证。

其他方法：

1. lintavailablePermits()：返回此信号量中当前可用的许可证数。
2. intgetQueueLength()：返回正在等待获取许可证的线程数。
3. booleanhasQueuedThreads():是否有线程正在等待获取许可证。
4. void reducePermits (int reduction):减少reduction个许可证，是个protected方法。
5. Collection getQueuedThreads()：返回所有等待获取许可证的线程集合，是个protected方法。

Java中的线程池：

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。

• 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

线程池的实现原理：

当向线程池提交一个任务之后，线程池是如何处理这个任务的呢？

1. 提交任务后，线程池先判断线程数是否已经达到了核心线程数，如果没有达到核心线程数，那么就创建一个核心线程来执行任务，否则进入下一个流程。
2. 接着线程池判断任务队列是否满了，如果没有满，则将任务添加到任务队列中；否则就执行下一步操作。
3. 这时，如果任务队列满了，那么就判断线程数是否已经达到了最大线程数，如果没有，就继续创建非核心线程来执行任务，否则，就执行饱和策略，默认会抛出RejectedExecutionException异常。

ThreadPoolExecutor执行execute方法分为下面四种情况：

1. 如果当前运行的线程少于corePoolSize，则创建新线程来执行任务(注意，执行这步骤需要获取全局锁)。
2. 如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。
3. 如果无法将任务加入BlackingQueue(队列已满)，则创建新的线程来处理在务(注意执行这一步骤需要获取全局锁)。
4. 如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

ThreadPoolExecutor采取上述步骤的总体设计思路，是为了在执行execute()方法时，尽可能地避免获取全局锁(那将会是一个严重的可伸缩瓶颈)。在ThreadPoolExecutor完成预热之后(当前运行的线程数大于等于corePoolSize)，几乎所有的execute()方法调用都是执行步骤2，而步骤2不需要获取全局锁。

线程池的使用：

1.线程池的创建：

创建线程池时需要输入几个参数，如下：corePoolSize(线程池的基本大小)，runableTaskQuoue(任务队列)，用于保存等待执行的任务的阻塞队列，可以选择LinkedBlockingQueue，ArrayBlockingQueue，SynchronousQueue，PriorityBlockingQueue。maximumPoolSize(线程池最大数量)：线程池允许创建的最大线程数；ThreadFactory：用于设置创建线程的工厂；RjectedExecutionHandler (饱和策略)：在JDK 1.5中Java线程池框架提供了以下4种策略（AbortPolicy：直接抛出异常。CallerRunsPolicy:只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。DiscardPolicy：不处理，丢弃掉。当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略）。

2.向线程池提交任务：

可以使用两个方法向线程池提交任务，分别为execute 和submit方法。execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个 future对象可以判断任务是否执行成功，并耳可以通过future的get()方法来获取返回值，get方法会阻塞当前线程直到任务完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

3.关闭线程池：

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程 所以无法响应中断的任务可能永远无法终止。但是它们存在一定的区别，shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

4.合理配置线程池：

要想合理地配置线程池，就必须首先分析任务特性，可以从以下几个角度来分析。任务的性质：CPU密集型任务、IO密集型任务和混合型任务。任务的优先级：高、中和低。任务的执行时间：长、中和短。任务的依赖性：是否依赖其他系统资源，如数据库连接。性质不同的任务可以用不同规模的线程池分开处理。优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。建议使用有界队列。

5.线程池的监控：

如果在系统中大量使用线程池，则有必要对线程池进行监控，方便在出现问题时，可以根据线程池的使用状况快速定位问题。可以通过线程池提供的参数进行监控，在监控线程池的时候可以使用以下属性。taskCount:线程池需要执行的任务数量。completedTaskCount:线程池在运行过程中已完成的任务数量，小于或等于taskCount。fargestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。getActiveCount：获取活动的线程数。通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute，afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。

Executor框架：

在Java中，使用线程来异步执行任务。Java线程的创建与销毁需要一定的开销，如果我们为每一个任务都创建一个新线程来执行，这些线程的创建与销毁将消耗大量的计算资源。同时为每个任务创建一个新线程来执行，这种策略可能会使处于高负荷状态的应用最终崩溃。Java的线程既是工作单元，也是执行机制。从JDK5开始，把工作单元与执行机制分离开来。工作单元包括Runnable和Callable，而执行机制由Executor框架提供。

Executor框架简介：

1. Executor框架的两级调度模型：

在HotSpot VM的线程模型中，Java线程(java.lang.Thread)被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，这个操作系统线程也会被回收。操作系统会调度所有线程并将它们分配给可用的CPU。在上层，Java多线程程序通常把应用分解为若干个任务，然后使用用户级的调度器(Executor框架)将这些任务映射为固定数量的线程；在底层，操作系统内核将这些线程映射到硬件处理器上。应用程序通过Executor框架控制上层的调度；而下层的调度由操作系统内核控制，下层的调度不受应用程序的控制。

2.Executor框架的结构与成员：

Executor框架主要由3大部分组成：

• 任务：包括被执行任务需要实现的接口：Runnable接口或Callable接口。
• 任务的执行：包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了ExecutorService接(ThreadPoolExecutor 和 ScheduledThreadPoolExecutor)。
• 异步计算的结果：包括接口 Future和实现Future接口的FutureTask类。

Executor框架包含的主要的类与接口：

• Executor是一个接口，它是Executor框架的基础，它将任务的提交与任务的执行分离开来。
• ThreadPoolExecutor是线程池的核心实现类，用来执行被提交的任务。
• ScheduledThreadPoolExecutor是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPaolExecutor比Timer更灵活，功能更强大。
• Future 接口和实现Future接口的Future Task类，代表异步计算的结果。
• Runnabte接口和Callable接口的实现类，都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

Executor框架执行流程：

主线程首先要创建实现Runnable或者Callable接口的任务对象。工具类Executors可以把一个Runnable对象封装为一个Callable对象(Executors.callable (Runnable task)或Executors.callable (Runnable task, Object resule))。然后可以把Runnable对象直接交给ExecutorService 执行(ExecutorService.execute (Runnablecommand))；或者也可以把Runnable对象或Callable对象提交给 ExecutorService执行(Executor.Service.submit (Runnable task)或ExecutorService.submit (Callable<T> task))。如果执行 ExecutorService.submit (…).ExecutorService将返回一个实现Future接口的对象(到目前为止的JDK中，返回的是FutureTask对象)。由于FutureTask实现了Runnable.程序员也可以创建 Future Task，然后直接交给ExecutorService执行。最后，主线程可以执行Future Task get(方法来等待任务执行完成。主线程也可以执行FutureTask.cancel (boolean mayInterruptlfRunning)来取消此任务的执行。

Executor 框架的成员：

Executor框架的主要成员：ThreadPoolExecutor、ScheduledThreadPoolExecutor，Future 接口、Runnable接口、Callable接口和Executors。

1. ThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建3种类型的ThreadPoolExecutor：SingleThreadExecutor(创建使用单个线程的SingleThreadExecutor,SingleThreadExecutor适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景),FixedThreadPool(创建使用固定线程数的FixedThreadPool,适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器) 和CachedThreadPool(创建一个会根据需要创建新线程的CachedThreadPool，CachedThreadPool是大小无界的线程池，适用执行很多的短期异步任务的小程序，或者是负载较轻的服务器)。
2. ScheduledThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor,如下：ScheduledThreadPoolExecutor。包含若干个线程的ScheduledThreadPoolExecutor。SingleThreadScheduledExecutor。只包含一个线程的ScheduledThreadPoolExecutor。ScheduledThreadPoolExecutor适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。SingleThreadScheduledExecutor适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。
3. Future接口和实现Future接口的FutureTask类用来表示异步计算的结果。当我们把Runnable接口或Callable接口的实现类提交(submit)给ThreadPoolExecutor或者ScheduledThreadPoolExecutor时， ThreadPoolExecutor或ScheduledThreadPoolExecutor会向我们返回一个FutureTask对象。，到目前最新的JDK8为止，Java通过上述API返回的是一个FutureTask对象，但从API可以看到，java仅仅保证返回的是一个实现了Future 接口的对象在将来的JDK实现中，返回的可能不一定是FutureTask。
4. Runnable接口和Callable接口的实现类，都可以被ThreadPoolExecutor或 ScheduledThreadPoolExecutor执行。它们之间的区别是Runnable不会返回结果，而Callable可以返回结果。除了可以自己创建实现Callable接口的对象外，还可以使用工厂类Executors来把一个Runnable包装成一个Callable。

ThreadPoolExecutor ：

Executar框架最核心的类是ThreadPoolExecutor，它是线程池的实现类，主要由下列4个组件构成。corePool：核心线程池的大小。maximumPool：最大线程池的大小。BlockingQueue:用来暂时保存任务的工作队列。RejectedExecutionHandler:当ThreadPoolExecutor已经关闭或ThreadPoolExecutor已经饱和时(达到了最大线程池大小目工作队列已满).execnte方法将要调用的Handler。

1.FixedThreadPool：

FixedThreadPool被称为可重用固定线程数的线程池。FixedThreadPool的execute方法运行如下：

1. 如果当前运行的线程数少于corePoolSize，则创建新线程来执行任务。
2. 在线程池完成预热之后(当前运行的线程数等于corePoolSize)，将任务加人LinkedBlockingQueue。
3. 线程执行完1中的任务后，会在循环中反复从LinkedBlockingQueue获取任务执行。

FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列(队列的容量为Integer.MAX_VALUE)。使用无界队列作为工作队列会对线程池带来如下影响：

1. 当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中的线程数不会超过corePoolSize。
2. 由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3. 由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4. 由于使用无界队列，运行中的 FixedThreadPool(未执行方法 shutdown()或 shutdownNow))不会拒绝任务(不会调用RejectedExecutionHandler.rejectedExecution方法)。

2.SingleThreadExecutor：

SingleThreadExecutor是使用单个worker线程的Executor。SingleThreadExecutor的corePoolSize 和maximumPoolSize被设置为1。其他参数与FixedThreadPool相同。Single ThreadExecutor同样使用无界队列LinkedBlockingQueue作为线程池的工作队列(队列的容量为Integer.MAX_VALUE)。SingleThreadExecutor的execute方法运行如下：

1. 如果当前运行的线程数少于corePoolSize(即线程池中无运行的线程)，则创建一个新线程来执行任务。
2. 在线程池完成预热之后(当前线程池中有一个运行的线程)，将任务加入LinkedBlockingQueue。
3. 线程执行完1中的任务后，会在一个无限循环中反复从LinkedBlockingQueue获取任务来执行。

3.CachedThreadPool：

CachedThreadPool是一个会根据需要来创建新线程的线程池。CachedThreadPool的corePoolSize被设置为0.即corePool为空；maximumPoolSize被设置为Integer.MAX_VALUE，即maximumPool是无界的。这里把keepAliveTime设置为60L.意味着CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。FixedThreadPool和SingleThreadExecutor使用无界队列LinkedBlockingQueue作为线程池的工作队列。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但CachedThreadPool的maximumPool是无界的。这意味着，如果主线程提交任务的速度高于maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。CachedThreadPool的execute()方法的执行如下：

1. 首先执行 SynchronousQueue. offer (Runnable task)。如果当前maximumPool中有空闲线程正在执行SynchronousQueve. poll(keepAliveTime, TimeUnit.NANOSECONDS)，那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成；否则执行下面的步骤2)。
2. 当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行 SynchronousQueue. poll (keepAliveTime, TimeUnit.NANOSECONDS)。这种情况下，步骤1)将失败。此时CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。
3. 在步骤2)中新创建的线程将任务执行完后，会执行SynchronousQueue. poll(keepAliveTime，TimeUnit.NANOSECONDS)。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒，如果60秒内主线程提供了一个新任务，那么执行步骤1，否则将终止该空闲线程。因此长时间保持空闲的CachedThreadPool不会使用任何资源。

ScheduledThreadPoolExecutor ：

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor的功能与Timer类似，但ScheduledThreadPoolExecutor功能更强大、更灵活。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

ScheduledThreadPoolExecutor的运行机制：

ScheduledThreadPoolExecutor的执行如下：

1. 当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate方法或者scheduleWithFixedDela方法时，会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduEutu接口的ScheduledFutureTask。
2. 线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

 FutureTask 简介：

Futrue接口和实现Futrue接口的FutrueTask类，代表异步计算的结果。FutureTask除了实现Future接口外，还实现了Runnable接口。因此，FutureTask 可以交给Executor执行，也可以由调用线程直接执行(FutureTask.run())。根据Future Task.run0法被执行的时机，FutureTask可以处于下面3种状态：

1. 未启动。FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态。当创建一个FutureTask，且没有执行FutureTask.run()方法之前，这个FutureTask处于未启动状态。
2. 已启动。FutureTask.run()方法被执行的过程中，FutureTask处于已启动状态。
3. 已完成。FutureTask.run()方法执行完后正常结束，或被取消(FutureTask.cancel(··…))或执行FutureTask.run()方法时抛出异常而异常结束，FutureTask处于已完成状态。

当Fature Task处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞，当FutureTask处于已完成状态时，执行FutureTask.get方法将导致调用线程立即返回结果或抛出异常。FutureTask处于未启动状态时，执行FutureTask.cancel方法将导致此任务永远不会被执行：当FutureTask处于已启动状态时，执行FutureTask.cancel (true)方法将以中断我行此任务线程的方式来试图停止任务；当FutureTask处于已启动状态时，执行FutureTaskcancel(false)方法将不会对正在执行此任务的线程产生影响(让正在执行的任务运行完成)；当FutureTask处于已完成状态时，执行EutureTask.cancel()方法将返回false。注意：FutrueTask的实现基于AQS。

生产者和消费者模式:

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序整体处理数据的速度。在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力太于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，便有了生产者和消费者模式。（以阻塞队列作为缓冲区，平衡了生产者和消费者的处理能力）

使用场景：

在多核时代，多线程并发处理速度比单线程阻塞处理速度更快。所以可以使用多个线程来生产数据，同样可以使用多个消费线程来 消费者消费数据。而更复杂的情况是，消费者消费数据之后，有可能需要继续处理，于是消费者处理完数据之后，它又要作为生产者把数据 阻塞队列放在新的队列里，交给其他消费者继续处理。

线程池与生产者和消费者模式：

Java中的线程池类其实就是一种生产者和消费者模式的实现方式，但是我觉得其实现方式更加高明。生产者把任务丢给线程池，线程池创建线程并处理任务，如果将要运行的任务数大于线程池的基本线程数就把任务扔到阻塞队列里，这种做法比只使用一个阻塞队列来实现生产者和消费者模式显然要高明很多，因为消费者能够处理直接就处理掉了，这样速度更快，而生产者先存，消费者再取这种方式显然慢一些。

线上问题定位：

有时候，有很多问题只有在线上或者在预发环境才能发现，而线上又不能调试代码，所有线上问题定位就只能看日志，系统状态和dump线程。可以：

1. 在Linux系统命令行下使用TOP命令查看每个进程的情况。（因为是Java应用，所以只需要关注COMMAND是Java的性能数据，其中COMMAND表示启动当前进程的命令）
2. 再使用top的交互命令数字1查看每个CPU的性能数据。
3. 使用top的交互命令H可以查看每个线程的性能信息。（如果某个线程CPU利用率一直100%，说明有可能死循环。如果某个线程一直在top10的位置，说明可能有性能问题。如果CPU利用率高的几个线程不停的变化，说明并不是由一个线程导致CPU偏高）