1、建立线程html
1.使用Executor:java.util.concurrent包中的执行器（Execute)为你管理Thread对象，从而简化并发编程。java
package thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class LiftOff implements Runnable{ public int countDown=10;//倒计时十个数 public static int taskNumber=0;//静态的，多个LiftOff对象共享这一个变量 public final int id=taskNumber++;//id是惟一的 public void status(){ System.out.println(id+"的倒计时是："+countDown); } @Override public void run() { while (countDown-->0){ status(); Thread.yield(); } } public static void main(String[] args) { ExecutorService exe = Executors.newCachedThreadPool(); for(int i=0;i<5;i++){ exe.execute(new LiftOff()); }
exe.shutdown();
} }
其中，shutdown方法的调用，是防止新任务被提交给这个Executor,当前线程（这里指main线程），将继续运行在shutdown被调用以前提交的任务，这个程序将在Executor中的全部任务完成以后尽快退出。程序员
1.2.FixedThreadPool（5）编程
1.3SingleThreadExecutor数组
2.从任务中产生返回值缓存
package thread; import java.util.ArrayList; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class TaskWithResult implements Callable<String> { private int id; public TaskWithResult(int id){ this.id=id; } @Override public String call() throws Exception { return "Result id is:"+id; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); ArrayList<Future<String>> result = new ArrayList<Future<String>>(); for(int i=0;i<5;i++){ result.add(executorService.submit(new TaskWithResult(i))); } for (Future<String> i:result ) { try { System.out.println(i.get()); }catch (Exception e){ e.printStackTrace(); }finally { executorService.shutdown(); } } } }
submit方法会产生Future对象，它用Callable返回结果的特色类型进行了参数化，你能够用isDone方法查询Future是否已经完成。当任务完成 时，它有一个结果，你能够调用get方法获取结果，get将被阻塞，直至数据准备就绪。并发
3。sleep()ide
对sleep的调用能够抛出InterruptException异常，而且你能够看到，它在run中被捕获，由于异常不能跨线程传播回main(),全部你必须在本地处理全部在任务内部产生的异常。this
2、Executor Frame Work(java.util.concurrent.*)spa
1.分离任务的建立和执行者的建立
2.线程重复利用（new线程代价很大）
共享线程池概念：预先设好多个Thread，可弹性增长，屡次执行不少很小的任务，任务建立和执行解耦。程序员无需关心线程池执行任务过程。
Executor主要类：ExecutorService,ThreadPoolExecutor,Future
Executors.newCachedThreadPool/newFixedThreadPool 固定大小/可动态改变
Callable具体的逻辑对象（线程类）
Future 返回结果
前面讲的不是很系统，如今从线程池的最核心类ThreadPoolExecutor讲起
1、Java中的ThreadPoolExecutor
java.util.concurrent.ThreadPoolExecutor类是线程池中最核心的类，在其中提供了四个构造方法
public class ThreadPoolExecutor extends AbstractExecutorService { ..... public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler); ... }
从上面的代码可知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，经过观察每一个构造器的源码实现，发现前面三个构造器都是调用第四个构造器进行初始化。
下面解释一下各个构造器的各个参数
corePoolSize:核心池的大小，这个参数跟后面讲的线程池实现原理有很是大的关系。在建立了线程池后，默认状况下，线程池中并无任何数据，而是等待有任务到来才建立线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreTherad()方法，即预建立线程，即在没有任务到来以前就建立corePoolSize个线程或者一个线程。默认状况下，在建立了线程池后，线程池中的线程数为0，当有任务来以后，就会建立一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列中。
maximunPoolSize：线程池最大线程数，这个参数也是很是重要的，它表示线程池中最多能够建立多少个线程。
keepAliveTime:表示线程没有执行任务时最多会保持多久时间会终止，默认状况下，只有当线程池中线程数大于corePoolSize时，keepAliveTime才会起做用，直到线程池中线程数不大于corePoolSize。可是若是调用了allowCoreThreadTimeOut（boolean）方法，在线程池中线程数不大于corePoolSize时，keepAliveTime也会起做用，直到线程池中线程数为0。
unit：参数keepAliveTime的时间单位，有七种取值，在TimeUnit中有7中静态属性
TimeUnit.DAYS; //天 TimeUnit.HOURS; //小时 TimeUnit.MINUTES; //分钟 TimeUnit.SECONDS; //秒 TimeUnit.MILLISECONDS; //毫秒 TimeUnit.MICROSECONDS; //微妙 TimeUnit.NANOSECONDS; //纳秒
workQueue:一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生极大影响，通常来讲，这里的阻塞队列有如下几种选择：
ArrayBlockingQueue; LinkedBlockingQueue; SynchronousQueue;
通常使用的时LinkedBlockingQueue与SynchronousQueue，线程池的排队策略与BlockQueue有关。
threadFactory：线程工厂，主要用来建立线程。
handler：表示当拒绝处理任务时的策略，有如下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
ThreadPoolExecutor继承AbstractExecutorService(抽象类），AbstractExecutorService实现了ExecutorService接口，ExecutorService接口又继承了Executor接口。
public interface Executor { void execute(Runnable command); }
此接口中定义的方法时用来执行传入的任务的。
而后ExecutorService接口继承了Executor接口，并声明了一些方法：submit,invokeAll,invokeAny以及shutDown等。
抽象类AbstractExecutorService实现了ExecutorService基本实现了ExecutorService中实现 的方法。
ThreadPoolExecutor几个重要的方法：
execute() submit() shutdown() shutdownNow()
executor方法实际上时Executor中声明的方法，经过这个方法能够向线程池提交一个任务，交由线程池去管理。
submit（）方法时ExecutorService中声明的方法，在AbstractExecutorService中就已经有了具体实现，这个方法也是用来向线程池提交任务的，可是它和executor方法不一样，它能返回任务执行的结果，它内部仍是用executor方法，只不过它利用了Future来获取任务执行结果。
shutdown与shutdownNow是用来关闭线程池的。
还有不少其余的方法：
好比：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等获取与线程池相关属性的方法，有兴趣的朋友能够自行查阅API。
2、深刻剖析线程池实现原理
在上一节咱们从宏观上介绍了ThreadPoolExecutor，下面咱们来深刻解析一下线程池的具体实现原理，将从下面几个方面讲解：
1.线程池状态
2.任务的执行
3.线程池中的线程初始化
4.任务缓存队列及排队策略
5.任务拒绝策略
6.线程池的关闭
7.线程池容量的动态调整
1.线程池状态
在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：
volatile int runState; static final int RUNNING = 0; static final int SHUTDOWN = 1; static final int STOP = 2; static final int TERMINATED = 3;
RunState表示当前线程池的状态，它是一个volatile变量来保证各线程之间的可见性
下面的几个static final 变量表示RunState可能的几个取值
当线程池建立之后，初始时，线程池处于RUNNING状态；
若是调用了shutdown方法后，则线程池处于SHUTDOWN状态，此时线程池不能接受新任务，它会等待全部任务执行完毕。
若是调用了shutdownNow方法，则线程处于STOP状态，此时线程池不能接受新任务，而且回去尝试终止正在执行的任务。
当线程池处于SHUTDOWN或STOP状态，而且全部的工做线程已经被销毁，任务缓存队列已经清空或执行结束后，线程池被置为TERMINATED状态。
2.执行的任务
在了解将任务提交给线程池到任务执行完毕整个过程以前，咱们先来看一下ThreadPoolExecutor类中其余的一些比较重要成员变量：
private final BlockingQueue<Runnable> workQueue; //任务缓存队列，用来存放等待执行的任务 private final ReentrantLock mainLock = new ReentrantLock(); //线程池的主要状态锁，对线程池状态（好比线程池大小 //、runState等）的改变都要使用这个锁 private final HashSet<Worker> workers = new HashSet<Worker>(); //用来存放工做集 private volatile long keepAliveTime; //线程存货时间 private volatile boolean allowCoreThreadTimeOut; //是否容许为核心线程设置存活时间 private volatile int corePoolSize; //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列） private volatile int maximumPoolSize; //线程池最大能容忍的线程数 private volatile int poolSize; //线程池中当前的线程数 private volatile RejectedExecutionHandler handler; //任务拒绝策略 private volatile ThreadFactory threadFactory; //线程工厂，用来建立线程 private int largestPoolSize; //用来记录线程池中曾经出现过的最大线程数 private long completedTaskCount; //用来记录已经执行完毕的任务个数
每一个变量的做用都已经标明出来了，这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。
corePoolSize在不少地方被翻译成核心池大小，其实个人理解这个就是线程池的大小。举个简单的例子：
假若有一个工厂，工厂里面有10个工人，每一个工人同时只能作一件任务。
所以只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人作；
当10个工人都有任务在作时，若是还来了任务，就把任务进行排队等待；
若是说新任务数目增加的速度远远大于工人作任务的速度，那么此时工厂主管可能会想补救措施，好比从新招4个临时工人进来；
而后就将任务也分配给这4个临时工人作；
若是说着14个工人作任务的速度仍是不够，此时工厂主管可能就要考虑再也不接收新的任务或者抛弃前面的一些任务了。
当这14个工人当中有人空闲时，而新任务增加的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。
这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。
也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量忽然过大时的一种补救措施。
不过为了方便理解，在本文后面仍是将corePoolSize翻译成核心池大小。
largestPoolSize只是一个用来起记录做用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。
下面咱们进入正题，看一下任务从提交到最终执行完毕经历了哪些过程。
在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，虽然经过submit也能够提交任务，可是实际上submit方法里面最终调用的仍是execute()方法，因此咱们只须要研究execute()方法的实现原理便可：
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { if (runState == RUNNING && workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); // is shutdown or saturated } }
首先是判断提交的任务command是不是null，如果null，则抛出空指针异常。
接着是这句：
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))
因为是或条件运算，若是线程池中的线程数大于等于核心池数，那么直接进入下面的if语句块，若是线程池中线程数小于核心池数，则执行后半部分，也就是:
addIfUnderCorePoolSize(command)
若是执行完addIfUnderCorePoolSize这个方法返回false，则继续执行下面的if语句块，不然整个方法就直接执行完毕了。
若是执行完addIfUnderCorePoolSize这个方法返回false，而后接着判断：
if (runState == RUNNING && workQueue.offer(command))
若是当前线程池处于RUNNING状态，则将任务放入缓存队列，若是当前不处于RUNNING或者放入缓存队列失败，则执行：
addIfUnderMaximumPoolSize(command)
若是执行addIfUnderMaximumPoolSize失败，则执行reject方法进行拒绝任务处理。
回到前面：
if (runState == RUNNING && workQueue.offer(command))
这句的执行，若是成功，则进行判断
if (runState != RUNNING || poolSize == 0)
这句判断是为了防止在将此任务添加进任务缓存队列的同时其余线程忽然调用shutdown或者shutdownNow方法关闭了线程池的一种应急措施。若是是这样就执行：
ensureQueuedTaskHandled(command)
进行应急处理，从名字能够看出是保证 添加到任务缓存队列中的任务获得处理。
咱们接着看2个关键方法的实现：addIfUnderCorePoolSize和addIfUnderMaximumPoolSize：
private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask); //建立线程去执行firstTask任务 } finally { mainLock.unlock(); } if (t == null) return false; t.start(); return true; }
这个是addIfUnderCorePoolSize方法的具体实现，从名字能够看出它的意图就是当低于核心吃大小时执行的方法。下面看其具体实现，首先获取到锁，由于这地方涉及到线程池状态的变化，先经过if语句判断当前线程池中的线程数目是否小于核心池大小，有朋友也许会有疑问：前面在execute()方法中不是已经判断过了吗，只有线程池当前线程数目小于核心池大小才会执行addIfUnderCorePoolSize方法的，为什么这地方还要继续判断？缘由很简单，前面的判断过程当中并无加锁，所以可能在execute方法判断的时候poolSize小于corePoolSize，而判断完以后，在其余线程中又向线程池提交了任务，就可能致使poolSize不小于corePoolSize了，因此须要在这个地方继续判断。而后接着判断线程池的状态是否为RUNNING，缘由也很简单，由于有可能在其余线程中调用了shutdown或者shutdownNow方法。而后就是执行
t = addThread(firstTask);
这个方法也很是关键，传进去的参数为提交的任务，返回值为Thread类型。而后接着在下面判断t是否为空，为空则代表建立线程失败（即poolSize>=corePoolSize或者runState不等于RUNNING），不然调用t.start()方法启动线程。
咱们来看一下addThread方法的实现：
private Thread addThread(Runnable firstTask) { Worker w = new Worker(firstTask); Thread t = threadFactory.newThread(w); //建立一个线程，执行任务 if (t != null) { w.thread = t; //将建立的线程的引用赋值为w的成员变量 workers.add(w); int nt = ++poolSize; //当前线程数加1 if (nt > largestPoolSize) largestPoolSize = nt; } return t; }
https://www.cnblogs.com/dolphin0520/p/3932921.html
到这里，大部分朋友应该对任务提交给线程池以后到被执行的整个过程有了一个基本的了解，下面总结一下：
1）首先，要清楚corePoolSize和maximumPoolSize的含义；
2）其次，要知道Worker是用来起到什么做用的；（既然Worker实现了Runnable接口，从run方法的实现能够看出，它首先执行的是经过构造器传进来的任务firstTask，在调用runTask()执行完firstTask以后，在while循环里面不断经过getTask()去取新的任务来执行，那么去哪里取呢？天然是从任务缓存队列里面去取，getTask是ThreadPoolExecutor类中的方法，并非Worker类中的方法）
3）要知道任务提交给线程池以后的处理策略，这里总结一下主要有4点：
- 若是当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会建立一个线程去执行这个任务；
- 若是当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（通常来讲是任务缓存队列已满），则会尝试建立新的线程去执行这个任务；
- 若是当前线程池中的线程数目达到maximumPoolSize，则会采起任务拒绝策略进行处理；
- 若是线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；若是容许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。
3.线程池中线程初始化
默认状况下，建立线程池以后，线程池中是没有线程的，须要提交任务以后才会建立线程。
在实际中若是须要线程池建立以后当即建立线程，能够经过如下两个方法办到：
- prestartCoreThread()：初始化一个核心线程；
- prestartAllCoreThreads()：初始化全部核心线程
- 下面是这2个方法的实现：
public boolean prestartCoreThread() { return addIfUnderCorePoolSize(null); //注意传进去的参数是null } public int prestartAllCoreThreads() { int n = 0; while (addIfUnderCorePoolSize(null))//注意传进去的参数是null ++n; return n; }
注意上面传进去的参数是null，根据第2小节的分析可知若是传进去的参数为null，则最后执行线程会阻塞在getTask方法中的
|
1
|
r = workQueue.take();
|
即等待任务队列中有任务。
4.任务缓存及排队策略
在前面咱们屡次提到了任务缓存队列，即workQueue，它用来存放等待执行的任务。
workQueue的类型为BlockingQueue<Runnable>，一般能够取下面三种类型：
1）ArrayBlockingQueue：基于数组的先进先出队列，此队列建立时必须指定大小；
2）LinkedBlockingQueue：基于链表的先进先出队列，若是建立时没有指定此队列大小，则默认为Integer.MAX_VALUE；
3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
5.任务拒绝策略
当线程池的任务缓存队列已满而且线程池中的线程数目达到maximumPoolSize，若是还有任务到来就会采起任务拒绝策略，一般有如下四种策略：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
6.线程池容量的动态调整
ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，
- setCorePoolSize：设置核心池大小
- setMaximumPoolSize：设置线程池最大能建立的线程数目大小
当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能当即建立新的线程来执行任务。
3、具体使用
不过在java doc中，并不提倡咱们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来建立线程池：
Executors.newCachedThreadPool(); //建立一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE Executors.newSingleThreadExecutor(); //建立容量为1的缓冲池 Executors.newFixedThreadPool(int); //建立固定容量大小的缓冲池
下面是这三个静态方法的具体实现;
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); } public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
从它们的具体实现来看，它们实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了。
newFixedThreadPool建立的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；
newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue；
newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就建立线程运行，当线程空闲超过60秒，就销毁线程。
实际中，若是Executors提供的三个静态方法能知足要求，就尽可能使用它提供的三个方法，由于本身去手动配置ThreadPoolExecutor的参数有点麻烦，要根据实际任务的类型和数量来进行配置。
另外，若是ThreadPoolExecutor达不到要求，能够本身继承ThreadPoolExecutor类进行重写。
4、如何合理配置线程池大小
本节来讨论一个比较重要的话题：如何合理配置线程池大小，仅供参考。
通常须要根据任务的类型来配置线程池大小：
若是是CPU密集型任务，就须要尽可能压榨CPU，参考值能够设为 NCPU+1
若是是IO密集型任务，参考值能够设置为2*NCPU
固然，这只是一个参考值，具体的设置还须要根据实际状况进行调整，好比能够先将线程池大小设置为参考值，再观察任务运行状况和系统负载、资源利用率来进行适当调整。