线程池（一）
一：创建线程的几种方式
1：继承Thread。
其实Thread这个类实现了Runnable这个接口，所以我们可以直接通过继承Thread然后重写run方法，直接new子类start就可以创建一个线程来执行。
2：实现Runnable。
我们知道Java中是单继承多实现的，所以通过继承实现有很大的局限性，我们通过实现Runnable接口，向Thread传入实例来启动一个线程。
3：实现Callable<V>接口来得到有返回值的方法。
我们上面实现的方式调用run方法是没有返回值，在1.5开始提供了Callable接口可以实现有返回值的调用。
我们可以通过 futureTask.get() 来得到执行返回结果，而且这个方法是阻塞的。
我们可以简单看下源码，是怎么执行。
1）Callable只有方法待实现
2）FutureTask实现了 RunnableFuture，而它是继承Runnable的，所以我们看出FutureTask其实就是个Runnable实现类，所以上面使用的时候可以把它传递Thread构造器。
那么它肯定实现了Run方法，看下怎么实现的，我们构造FutureTask的时候传递了我们实现的Callable，就是下面c 实例
看到它调用了c.call，就是执行了我们定义的call方法把返回结果set(result)了。其实它就是把Runable的run方法封装了一层而且。
二：线程池
我们都知道线程的资源是很宝贵的，而且创建线程和销毁线程都需要花费资源，因此我们需要一种池化的技术来管理线程，不让他频繁的创建回收，达到复用的效果。
在Java中提供了一个工具类Executors来创建几种线程池。
我们主要来看其中的三种。
ExecutorService executorService1 = Executors.newFixedThreadPool(10); ExecutorService executorService2 = Executors.newCachedThreadPool(); ExecutorService executorService3 = Executors.newSingleThreadExecutor();
我们根据上面创建的线程池提交任务就可以实现多线程处理。
有两种提交任务的方式，一种submit，一种execute。
从上面的也可以看出submit是可以有返回值的，execute是没有返回值的。
点进去看会发现他们都是调用的同一个构造器，只是传递的参数不同而已。
public ThreadPoolExecutor ( int corePoolSize, //核心线程数 int maximumPoolSize, //最大线程数=核心线程数+非核心线程数 long keepAliveTime, //非核心线程数最大存活空闲时间 TimeUnit unit, //实现的单位 BlockingQueue<Runnable> workQueue, // 阻塞队列 ThreadFactory threadFactory, //线程工厂 RejectedExecutionHandler handler) //拒绝策略
1）： Executors.newFixedThreadPool(10);
所以它创建出来的线程池只有核心线程数，没有非核心线程数，使用的阻塞队列 LinkedBlockingQueue
而 new LinkedBlockingQueue<Runnable>()默认会创建一个无界队列。最大值2的31次方-1,算是无界的队列。
关于阻塞队列后面会单独写篇博客记录。
2）Executors.newCachedThreadPool();
这个线程池没有核心线程数，只有非核心线程数，而且非核心线程数是2的31次方-1，使用的阻塞队列是 SynchronousQueue
3）Executors.newSingleThreadExecutor();
顾名思义就只有一个核心线程数，没有非核心线程数，阻塞队列是LinkedBlockingQueue
在阿里巴巴的开发手册中并推荐我们直接使用Executors中给我提供的创建线程池的方式来进行创建，因为我们从上面看到第一种线程池队列无界，可能导致队列里添加了很多任务占用内存而我们却不知道。
第二种是非核心线程数没有上限，这肯定也不安全。所以它推荐我们直接使用 ThreadPoolExecutor 构造器来创建自己的线程池，自己控制线程数和阻塞队列的长度。
关于任务提交到线程池还有一点需要说明就是提交顺序和执行顺序。
所以有时候我们会看到任务处理的顺序和我们提交的顺序不一样，这就是原因。
三：线程池源码分析
我们上面说，submit有返回值，execute没有返回值，其实底层submit也是调用execute的。
这个submit是在 AbstractExecutorService 抽象类中，我们看到，它把我们传入的task封装成了FutureTask。
这个newTaskFor的动作是protected的，是可以扩展的。
1：我们来看execute(task) 方法。
它是Executor接口中的方法。实现是在 ThreadPoolExecutor 中。
int c = ctl.get();
// 如果线程数量小于核心线程数量，直接addWorker创建新的线程执行任务 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); }
// 判断线程池是运行的，队列还未满，任务直接放入队列中 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get();
//再次检查运行状态，如果不再运行就把队列里的任务删除，然后拒绝任务 if (! isRunning(recheck) && remove(command)) reject(command);
//如果线程的数量为0，调用addWorker增加线程执行任务 else if (workerCountOf(recheck) == 0) addWorker(null, false); } else if (!addWorker(command, false)) reject(command); }
对应我们上面说的，任务提交之后，先交给核心线程-》队列中-》非核心线程
我们看下addWorker做了什么
private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { 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 rs = runStateOf(ctl.get()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); workers.add(w); int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); } return workerStarted; }
总的来说就是判断线程池是可运行状态，把我们传入的task封装成一个内部Worker类，Worker类内维护一个线程，最后启动这个线程就会执行Worker中的run方法，
我们看到Worker是AQS，Runnable的。
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为null,就从队列里面获取 getTask()从当前队列里获取 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); Throwable thrown = null; try {
// 注意这里是直接调用我们传入任务的run方法 task.run(); } catch (RuntimeException x) { thrown = x; throw x; } catch (Error x) { thrown = x; throw x; } catch (Throwable x) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }
