先说下结论：
如何实现线程和任务分离呢？
线程和任务都是实现了Runnable接口的类，不同的是，扮演线程的类通过start()方法创建线程并执行其中的run()方法，而扮演任务的类则不会调用start()方法，在线程的run()方法中能获取到任务的引用，并直接调用任务的run方法（无论是直接在run()方法中使用，还是在somemethod()方法中，然后在run()方法中调用somemethod()）．
如何实现不销毁的呢？
首先，纠正一点，有人说在使用线程池的时候，从中找一个空闲的线程拿过来用，用完了再放回线程池，这个说法很形象，但是并不准确．实际情况是，我们并不需要知道哪些空闲，也不是我们拿过来用，也不需要在用完以后放回线程池，我们只需要不停地提交给线程池我们需要完成的任务，线程池就会自己去创建线程（一定条件下）执行任务，或者那些已经创建的空闲的线程，在发现新的任务时，会主动去争取这个任务，并执行．而线程之所以不会被销毁，是因为要么，它在执行任务，要么它在等待任务．java线程池中的线程，会在创建之初被分配一个任务，在这个任务执行完后，就会去BlockingQueue阻塞队列中拿任务，如果拿不到，就会阻塞在那里，拿到了就执行，执行完了，继续去拿，如此循环往复（指定线程的存活时间，则等待任务一定时间后，还是拿不到，就会被销毁了）．
如何使用线程池？
public static void testThreadPoolExecutor() {
//１．创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200,
TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));
for(int i = 0; i < 15; i ++){
MyTask myTask = new MyTask(i);
//２．提交任务到线程池
executor.execute(myTask);
System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
executor.getQueue().size()+"，已执行完别的任务数目："+executor.getCompletedTaskCount());
}
//３．关闭线程池
executor.shutdown();
}
其中，自定义的task：
//１．实现Runnable接口，或者实现Thread类
class MyTask implements Runnable {
private int taskNum;
public MyTask(int num) {
this.taskNum = num;
}
//２．重写run方法
@Override
public void run() {
System.out.println("正在执行task "+taskNum + " 当前线程id为：" + Thread.currentThread().getId());
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("task "+taskNum+"执行完毕");
}
}
在执行提交任务到线程池的代码时，发生了什么呢？且看源码：
public void execute(Runnable command) {
if (command == null)
//１．抛异常
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
//２．调用addWorker()方法
if (addWorker(command, true))
return;
c = ctl.get();
}
//３．添加到workQueue
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
//４．拒绝任务
reject(command);
else if (workerCountOf(recheck) == 0)
//５．调用addWorker()方法
addWorker(null, false);
}
else if (!addWorker(command, false))
//６．调用addWorker()方法失败，则拒绝任务
reject(command);
}
提交任务到线程池，可能会有下面几种情况：
１．抛出异常
２．调用addWorker()方法
３．将任务添加到workQueue队列
４．拒绝任务
抛出异常和拒绝任务没什么好说的了，提交任务到队列，就是把任务添加到队列里，也没什么．现在需要研究的是addWorker()方法，做了什么？
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
// Check if queue empty only if necessary.
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
for (;;) {
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//上面的代码主要是检查一些参数，看还能不能添加worker，主要看下面的代码
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//１．这里又worker，又task,又thread的，他们之间什么关系呢？
//work是根据task创建的,thread t是从worker来的
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
//２．这里把新的worker添加到线程池的workers集合中了
workers.add(w);
workerAdded = true;
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//３．这里一个线程开始运行了，就是新创建的worker中的thread
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
上面源码中的注释３处，线程开始运行，实际执行的run()方法在哪里呢？
先看下ThreadPoolExecutor.Worker类的源码：
//１．注意Worker实现了Runnable接口
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
//省略
//２．主要看这三个属性
/** Thread this worker is running in. Null if factory fails. */
@SuppressWarnings("serial") // Unlikely to be serializable
final Thread thread;
/** Initial task to run. Possibly null. */
@SuppressWarnings("serial") // Not statically typed as Serializable
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
//３．主要看这两个方法，构造方法中，worker和自己的属性纠缠不清
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker. */
public void run() {
runWorker(this);
}
//省略．．．
}
上面提到，addWorke()方法中，最后有线程启动了，但是真正被执行的run方法在哪里呢？是不是Worker类中的run方法呢？
可以通过调试，加断点的方法证明，确实实际执行的run()方法就是Worker类中的run方法！同时也说明，此时启动的线程是新的worker的线程，在它的run()方法中虽然调用了线程池的runWorker()方法，但是，这个方法是在这个worker的线程中运行的．
接下来看下线程池的runWorker()方法的源码：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//１．循环获取task，从worker中获取task，或者通过getTask()方法获取task
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
try {
//2.首先应该明确这个runWorker()方法是在这个worker的线程中执行的，所以task的run方法虽然是作为普通方法调用的，但是也是在worker的线程中执行的．
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
一个worker对应线程池中的一个线程．在上面的源码中，我们可以看到，worker线程会循环获取任务，要么获取最初提交到worker中的task，要么通过调用线程池中的getTask()方法获取任务．这里也实现了线程和任务的分离（线程和任务都是实现了Runnable接口的类）．我们可以简单分析一下，最初提交到worker的任务执行完后，worker就会通过线程池的getTask()方法获取任务，如果能获取到，就可以继续处理了，如果获取不到呢？为什么没有被销毁呢？这就要看下getTask()的源码了：
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
//１．这是一个无限循环
for (;;) {
int c = ctl.get();
// Check if queue empty only if necessary.
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
//２．上面的是特殊情况的处理，看下面代码，从workQueue中获取任务
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
上面的workQueue是线程池的属性：
private final BlockingQueue<Runnable> workQueue;
阻塞队列，阻塞队列有什么特点呢？或者说它的poll()和take()方法有什么特点呢？
/**
* Retrieves and removes the head of this queue, waiting if necessary
* until an element becomes available.
*
* @return the head of this queue
* @throws InterruptedException if interrupted while waiting
*/
E take() throws InterruptedException;
/**
* Retrieves and removes the head of this queue, waiting up to the
* specified wait time if necessary for an element to become available.
*
* @param timeout how long to wait before giving up, in units of
* {@code unit}
* @param unit a {@code TimeUnit} determining how to interpret the
* {@code timeout} parameter
* @return the head of this queue, or {@code null} if the
* specified waiting time elapses before an element is available
* @throws InterruptedException if interrupted while waiting
*/
E poll(long timeout, TimeUnit unit)
throws InterruptedException;
注释说的是什么呢？调用这两个方法的线程，在获取不到元素时，会阻塞．poll和take的区别就是前者可以指定等待时间，后者则不行．
在核心线程获取不到任务时，如果没有指定核心线程的存活时间，会一直阻塞在take方法上，如果指定了核心线程的存活时间，则线程会阻塞在poll方法上，直到等待时间耗尽．这就实现了核心线程不销毁．
调用的顺序如下：
ThreadPoolExecutor.execute()---->ThreadPoolExecutor.addWorker()---->Worker.run()---->ThreadPoolExecutor..runWorker()---->BlockingQueue.take() || pBlockingQueue.take()||BlockingQueue.poll()
线程池基本原理和实现线程不销毁的基本方式，我们就清楚了．在这个基础上，对于其他的一些问题，我们也可以进行分析了．