今儿同事问了一个关于多线程的问题。一般的线程，在调用其start()方法之后，会自动开始执行相应的逻辑，如果之后再次调用start()，会怎么样？是否可以？？？每个线程其实是有多个状态的，刚刚创建之后，其处于NEW状态，在执行完相应的run()逻辑之后，其处理TERMINATED状态。如果多次调用这个start()方法，是否可以让逻辑执行多次呢？答案肯定是不行的（一个线程执行完自己的任务之后就被销毁了），所以多次执行start()必然不靠谱，应该会报错。同事又问到：那jdk线程池又是如何重用的呢？
jdk内部的ThreadPoolExecutor的实现
线程池内部相当于在跑一个while循环，在不断的从阻塞队列里拿task，之后调用task.run()，此时相应Runnable的run方法就会被执行，执行完以后继续去拿，如此反复，整个线程其实一直没有执行完成，所以，其状态也不会变成TERMINATED，就此实现了线程的重用。
java.util.concurrent.ThreadPoolExecutor
/** * Main run loop */public void run() { try { Runnable task = firstTask; firstTask = null; while (task != null || (task = getTask()) != null) { runTask(task); task = null; } } finally { workerDone(this); }}这个ThreadPoolExecutor内部的Worker即之前创建出来的线程，在这里不断的获取task，其runTask方法如下：
/** * Runs a single task between before/after methods. */private void runTask(Runnable task) { final ReentrantLock runLock = this.runLock; runLock.lock(); try { /* * Ensure that unless pool is stopping, this thread * does not have its interrupt set. This requires a * double-check of state in case the interrupt was * cleared concurrently with a shutdownNow -- if so, * the interrupt is re-enabled. */ if (runState < STOP && Thread.interrupted() && runState >= STOP) thread.interrupt(); /* * Track execution state to ensure that afterExecute * is called only if task completed or threw * exception. Otherwise, the caught runtime exception * will have been thrown by afterExecute itself, in * which case we don't want to call it again. */ boolean ran = false; beforeExecute(thread, task); try { task.run(); ran = true; afterExecute(task, null); ++completedTasks; } catch (RuntimeException ex) { if (!ran) afterExecute(task, ex); throw ex; } } finally { runLock.unlock(); }}注意task.run()这句，即总结的，调用Runnable的run方法。
用一个小例子来分析下整个线程池的执行任务的过程：
public class ThreadPoolTest { public static void main(String[] args) { ExecutorService exec = Executors.newFixedThreadPool(1); //设置固定线程池大小为1 List<Runnable> list = new ArrayList<Runnable>(); for(int i=0;i<5;i++) list.add(new MyRunnable()); for(int i=0;i<5;i++) exec.execute(list.get(i)); }}class MyRunnable implements Runnable { @Override public void run() { System.out.println("..."); //可以在此加断点DEUBG }}此时，exec会不断的向线程池中添加任务。
/** * Executes the given task sometime in the future. The task * may execute in a new thread or in an existing pooled thread. * * If the task cannot be submitted for execution, either because this * executor has been shutdown or because its capacity has been reached, * the task is handled by the current <tt>RejectedExecutionHandler</tt>. * * @param command the task to execute * @throws RejectedExecutionException at discretion of * <tt>RejectedExecutionHandler</tt>, if task cannot be accepted * for execution * @throws NullPointerException if command is null */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 } }}看到这个Runnable什么时候执行，是新创建线程执行，还是复用之前的线程，甚至是否需要拒绝请求。当前的线程池newFixedThreadPool(1)是个固定大小的池，此时poolSize == corePoolSize，所以此时的创建新线程的逻辑会返回false。
/** * Creates and starts a new thread running firstTask as its first * task, only if fewer than corePoolSize threads are running * and the pool is not shut down. * @param firstTask the task the new thread should run first (or * null if none) * @return true if successful */private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask); } finally { mainLock.unlock(); } if (t == null) return false; t.start(); return true;}所以，当前的command就被放入阻塞队列中workQueue.offer(command)，runTask中的task则是通过以下方法提到的：
Runnable getTask() { for (;;) { try { int state = runState; if (state > SHUTDOWN) return null; Runnable r; if (state == SHUTDOWN) // Help drain queue r = workQueue.poll(); else if (poolSize > corePoolSize || allowCoreThreadTimeOut) r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS); else r = workQueue.take(); if (r != null) return r; if (workerCanExit()) { if (runState >= SHUTDOWN) // Wake up others interruptIdleWorkers(); return null; } // Else retry } catch (InterruptedException ie) { // On interruption, re-check runState } }}此处是明显的生产者-消费者模式，其中生产者是Client，在外部不断的提交待执行的任务，消费者则是线程池内的线程，这两者之间通过阻塞队列workQueue建立起了连接，一个生产，一个执行待执行的任务的run方法将其消费。这时，线程中的线程是连续执行任务，还是会结束，在新任务出现时创建新的Worker线程，是由所使用的线程池类型决定的，例如：
ExecutorService exec = Executors.new Executors.newFixedThreadPool(2); //设置固定线程池大小为2线程池的固定线程数为2，其执行过程中是调用阻塞队列的take方法，此时如果队列中没有任务，是会一直阻塞。而如果使用CachedTharedPool，则会执行阻塞队列的poll方法，根据定义的超时时间进行等待。Worker在执行时，是执行阻塞队列的take方法还是poll方法，取决于timed是否为true，如下：
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;............... try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; }在使用CachedThreaPool时，由于共corePoolSize为0，所以每次执行时timed为true，此时执行阻塞队列的poll方法，keepAliveTime=60000000000后续返回时，此时由于队列中没有任务，所以timedOut=true，所以，在后续执行时
if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue;}此处会return null。
联系客服
