java线程
线程池
线程池可以看做是线程的集合。在没有任务时线程处于空闲状态，当请求到来：线程池给这个请求分配一个空闲的线程，任务完成后回到线程池中等待下次任务(而不是销毁)。这样就实现了线程的重用。
为每个请求开一个线程的缺点是：
- 线程生命周期的开销非常高。每个线程都有自己的生命周期，创建和销毁线程所花费的时间和资源可能比处理客户端的任务花费的时间和资源更多，并且还会有某些空闲线程也会占用资源。
- 程序的稳定性和健壮性会下降，每个请求开一个线程。如果受到了恶意攻击或者请求过多(内存不足)，程序很容易就奔溃。
Callable与Future
在线程池的api中有很多方法涉及到了这两个类。
Callable可以理解为是Runnable的扩展
他有返回值，能抛出受检查的异常
重写的是call（）方法
Future
表示一个可能还没有完成的异步任务的未来的结果，代表的是任务的生命周期，他有一些方法可以用于判断任务。
isDone() 判断任务是否已完成
isCancelled() 如果此任务在正常完成之前取消，则返回 true 。
cancel(boolean mayInterruptIfRunning) 尝试取消执行此任务
get() 等待任务计算完成 然后检索任务的结果
案例：
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newFixedThreadPool(2);
// 可以执行Runnable对象或者Callable对象代表的线程
Future<Integer> f1 = pool.submit(()->{
int sum = 0;
for (int x = 1; x <= 100; x++) {
sum += x;
}
return sum;
});
Future<Integer> f2 = pool.submit(()->{
int sum = 0;
for (int x = 1; x <= 200; x++) {
sum += x;
}
return sum;
});
System.out.println(f1.isDone());
Integer i1 = f1.get();
Integer i2 = f2.get();
System.out.println(i1);
System.out.println(i2);
pool.shutdown();
}
结果：
false
5050
20100
java中的线程池API
java中提供了一个接口Executor来让我们使用线程池
所有已知子接口:
ExecutorService-提供了线程池生命周期的管理方法
ScheduledExecutorService-安排线程池的延后与定期执行所有已知实现类：
AbstractExecutorService-提供默认实现
ForkJoinPool-提供了非ForkJoinTask客户端提交的入口点，以及管理与监视
ThreadPoolExecutor-最常用的线程池
ScheduledThreadPoolExecutor-安排线程池的延后与定期执行
Executor接口
public interface Executor {
// 用于执行任务
void execute(Runnable command);
}
ExecutorService接口：
管理生命周期的方法
//启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
shutdown()
//停止接受外部提交的任务，忽略队列中等待的任务，在正在执行的任务使用interrupt标记中断。
//Thread.interrupt();
shutdownNow()
//线程阻塞，直到所有已提交的任务执行完，或者等超时时间到，或线程被中断。
awaitTermination(long timeout, TimeUnit unit)
关闭功能
【从强到弱】 依次是：shuntdownNow() > shutdown() > awaitTermination()
执行的方法
submit(Runnable task) 提交Runnable任务以执行并返回表示该任务的Future。
用于执行给定的任务
invokeAll(Collection<? extends Callable<T>> tasks)
invokeAny(Collection<? extends Callable<T>> tasks)
AbstractExecutorService类
抽象类
newTaskFor(Callable<T> callable)
doInvokeAny(Collection<? extends Callable<T>> tasks, boolean timed, long nanos)
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
boolean timed, long nanos)
ScheduledExecutorService接口
schedule(Runnable command, long delay, TimeUnit unit)
schedule(Callable<V> callable, long delay, TimeUnit unit)
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
延期或者定期相关的方法，
参数1Runnable/Callable 任务
参数2 delay/initialDelay/period 相差的时间/ 延迟首次执行的时间/连续执行的时间间隔
参数3 unit - 延迟参数的时间单位
ThreadPoolExecutor类
提供了良好的扩展性，但是一般使用Executors就可以创建出常用了几种线程池了
如果需要自定义需要了解该类中的几个参数
核心线程数量（corePoolSize）
最大线程数量（maximumPoolsize）
1.如果运行的线程少于核心线程数量，则创建新线程执行任务，即使此时其他的辅助线程是空闲的
2.如果运行的线程大于核心线程数量，小于最大线程数量，则当队列塞满了才创建新线程
3.核心线程数量=最大线程数量时，代表创建了固定大小的线程池
4.如果设置了最大线程数量为基本的无界值（如Integer.MAX_VALUE)，那么允许池子适应任意数量的并发任务
按需初始化线程池
当任务请求过来时，才会初始化核心线程，可以使用方法重写
创建新线程
新创建的线程默认由线程工厂创建，属于同一个线程组，同优先级，没有守护线程。
线程如果创建失败，执行器会继续执行，但不会执行任务
线程空闲时间
keepAliveTime
如果线程数大于核心线程，然后空闲的线程时间大于设置的线程时间，那么线程就会销毁
阻塞队列（BlockingQueue）
阻塞是线程的状态，线程池处于忙碌的时候，任务就会排队。
1.如果少于核心线程的数量在执行，会创建一个新线程
2.如果队列满了，会先开一个线程来处理。
3.超过最大线程数就拒绝请求
排队的策略
1.同步，不把任务放到队列当中，直接移交给执行它的线程，一般用于线程池无界
2.无界限：如果所有的核心线程都在工作，那么新的线程会在队列中等待。（线程的创建不会多于核心线程数量）
3.有界限：避免资源耗尽，配合最大线程数使用
拒绝任务（线程池关闭，线程数量满了，队列饱和 Handler）
1.直接抛出异常，默认
2.用调用者所在的线程来执行任务
3.直接丢掉当前的任务
4.丢弃最旧的任务
钩子方法：扩展用，用于添加日志，计时，监控等
源代码：
//ctl 记录了“线程池中的任务数量”和“线程池的状态”两个信息。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
线程的状态：
RUNNING：线程池能够接受新任务，以及对新添加的任务进行处理。
SHUTDOWN：线程池不可以接受新任务，但是可以对已添加的任务进行处理。
STOP：线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
TIDYING：当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
TERMINATED：线程池彻底终止的状态。
-
状态 工作队列workers中的任务 阻塞队列中的任务 未添加的任务 RUNNING 继续处理 继续处理 添加 SHUTDOWN 继续处理 继续处理 不添加 STOP 尝试中断 不处理 不添加 TIDYING 处理完了 SHUTDOWN-TIDYING 处理完了；STOP-TIDYING 不处理 不添加 TERMINATED 同上 同上 不添加
newFiexedThreadPool
//创建一个固定线程数的线程池，返回一个corePoolSIze=maximumPoolSize的线程池
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>());
}
//SingleThreadExecutor
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
自定义线程池
通过构造方法，我们可以自定义一个线程池
public ThreadPoolExecutor(int corePoolSize,//指定核心线程数量
int maximumPoolSize,//指定最大线程数量
long keepAliveTime,//允许线程空闲时间
TimeUnit unit,//单位
BlockingQueue<Runnable> workQueue,//时间对象
ThreadFactory threadFactory,//线程工厂
RejectedExecutionHandler handler) {//任务拒绝策略
}
线程数量：
如果运行线程的数量少于核心线程数量，则创建新的线程处理请求
如果运行线程的数量大于核心线程数量，小于最大线程数量，则当队列满的时候才创建新的线程
如果核心线程数量等于最大线程数量，那么将创建固定大小的连接池
如果设置了最大线程数量为无穷，那么允许线程池适合任意的并发数量
线程空闲时间要点：
当前线程数大于核心线程数，如果空闲时间已经超过了，那该线程会销毁。
排队策略要点：
同步移交：不会放到队列中，而是等待线程执行它。如果当前线程没有执行，很可能会新开一个线程执行。
无界限策略：如果核心线程都在工作，该线程会放到队列中。所以线程数不会超过核心线程数
有界限策略：可以避免资源耗尽，但是一定程度上减低了吞吐量
当线程关闭或者线程数量满了和队列饱和了，就有拒绝任务的情况了：
拒绝任务策略：
直接抛出异常
使用调用者的线程来处理
直接丢掉这个任务
丢掉最老的任务
execute执行任务
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
//如果线程池中运行的线程数量<核心线程数量，则创建新线程来处理请求，即使其他辅助线程是空闲的。
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果线程池中运行的线程数量>=corePoolSize，且线程池处于RUNNING状态，且把提交的任务成功放入阻塞队列中，就再次检查线程池的状态，
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 如果线程池不是RUNNING状态，且成功从阻塞队列中删除任务，则该任务由当前 RejectedExecutionHandler 处理。
if (! isRunning(recheck) && remove(command))
reject(command);
// 如果线程池中运行的线程数量为0，则通过addWorker(null, false)尝试新建一个线程，新建线程对应的任务为null。
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 即没能将任务成功放入阻塞队列中，且addWoker新建线程失败，则该任务由当前 RejectedExecutionHandler 处理。
else if (!addWorker(command, false))
reject(command);
}
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
线程的关闭
线程的关闭有两个方法：
shutdown()
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
//锁对象锁定
mainLock.lock();
try {
checkShutdownAccess();
//设置线程状态
advanceRunState(SHUTDOWN);
//中断空闲的线程
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
//设置线程池的状态为TERMINATED
tryTerminate();
}
shutdownNow()
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
//设置状态为STOP
advanceRunState(STOP);
//中断
interruptWorkers();
//获取等待的任务列表
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
ScheduledThreadPoolExecutor类
可以用来在给定延时后执行异步任务或者周期性执行任务
ForkJoinPool类
JDK1.7新增加的线程池类。与与其它类型的ExecutorService相比，其主要的不同在于采用了工作窃取算法(work-stealing)：所有池中线程会尝试找到并执行已被提交到池中的或由其他线程创建的任务。这样很少有线程会处于空闲状态，非常高效。这使得能够有效地处理以下情景：大多数由任务产生大量子任务的情况；从外部客户端大量提交小任务到池中的情况。
