1、什么是线程池（为什么使用线程池）：
2、Executor框架介绍：
Java 5中引入的，其内部使用了线程池机制，在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭（使用该框架来创建线程池），可以简化并发编程的操作；
Executor框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等；
ExecutorService接口继承自Executor接口，提供了更丰富的实现多线程的方法，一般用该接口来实现和管理多线程；
ExecutorService的生命周期包括三种状态：运行、关闭、终止；创建后便进入运行状态；当调用了shutdown()方法时，便进入关闭状态，此时意味着 ExecutorService不再接受新的任务，但它还在执行已经提交了的任务；当所有已经提交了的任务执行完后，便到达终止状态；如果不调用shutdown()方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可；
更详细描述看：http://blog.csdn.net/ns_code/article/details/17465497
1 /**
2 * Executor执行Runnable任务
3 */
4 package thread05;
5
6 import java.util.concurrent.ExecutorService;
7 import java.util.concurrent.Executors;
8
9 public class ExecutorsTest01
10 {
11 public static void main(String[] args)
12 {
13 // ExecutorService executorService = Executors.newCachedThreadPool();
14 // ExecutorService executorService = Executors.newFixedThreadPool(4);
15 ExecutorService executorService = Executors.newSingleThreadExecutor();
16
17 // 创建5个任务并执行
18 for(int i=0;i<5;i++)
19 {
20 executorService.execute(new RunnableTest2());
21 }
22
23 // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
24 executorService.shutdown();
25 }
26 }
27
28 class RunnableTest2 implements Runnable
29 {
30 // 具体的业务逻辑；一旦RunnableTest2实例对象传给ExecutorService的execute方法， 则该方法（任务）自动在一个线程上执行
31 @Override
32 public void run()
33 {
34 System.out.println(Thread.currentThread().getName() + "线程被调用了");
35 }
36
37 }
Executor执行Runnable任务
1 /**
2 * Executor执行Callable任务
3 */
4 package thread05;
5
6 import java.util.ArrayList;
7 import java.util.List;
8 import java.util.concurrent.Callable;
9 import java.util.concurrent.ExecutionException;
10 import java.util.concurrent.ExecutorService;
11 import java.util.concurrent.Executors;
12 import java.util.concurrent.Future;
13
14 public class ExecutorsTest02
15 {
16 public static void main(String[] args)
17 {
18 ExecutorService executorService = Executors.newCachedThreadPool();
19 List<Future<String>> futureList = new ArrayList<Future<String>>();
20
21 // 创建10个任务并执行
22 for(int i=0;i<10;i++)
23 {
24 // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
25 Future<String> future = executorService.submit(new CallableTest2(i + ""));
26 // 将任务执行结果存储到List中
27 futureList.add(future);
28 }
29
30 // 遍历任务的结果
31 for(Future<String> f : futureList)
32 {
33 try
34 {
35 // Future返回如果没有完成，则一直循环等待，直到Future返回完成
36 while(!f.isDone());
37 // 打印各个线程（任务）执行的结果
38 System.out.println(f.get());
39 }
40 catch (InterruptedException | ExecutionException e)
41 {
42 e.printStackTrace();
43 }
44 finally
45 {
46 // 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
47 executorService.shutdown();
48 }
49 }
50
51 }
52 }
53
54 class CallableTest2 implements Callable<String>
55 {
56 private String id;
57
58 public CallableTest2(String id)
59 {
60 this.id = id;
61 }
62
63 // 具体的业务逻辑；一旦CallableTest2实例对象传给ExecutorService的submit方法， 则该方法（任务）自动在一个线程上执行
64 @Override
65 public String call() throws Exception
66 {
67 System.out.println("call()方法被自动调用，当前线程名称" + Thread.currentThread().getName());
68 return "call()方法被自动调用，任务的返回值：任务id：" + id + "，执行任务的线程名称：" + Thread.currentThread().getName();
69 }
70
71 }
Executor执行Callable任务
3、三种生成常用线程池的静态工厂方法（三种自带的线程池）：
newSingleThreadExecutor（SingleThreadExecutor）；
newCachedThreadPool（CachedThreadPool）；
newFixedThreadPool（FixedThreadPool）；
4、newSingleThreadExecutor的使用：
创建一个单线程的线程池，这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务；如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它；此线程池保证所有任务的执行顺序按照任务的提交顺序执行；
适用场景：适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景；
1 /**
2 * newSingleThreadExecutor的使用
3 */
4 package thread05;
5
6 import java.util.concurrent.ExecutorService;
7 import java.util.concurrent.Executors;
8
9 public class NewSingleThreadExecutorTest01
10 {
11 public static void main(String[] args)
12 {
13 ExecutorService executorService = Executors.newSingleThreadExecutor();
14
15 for(int i=0;i<5;i++)
16 {
17 final int no = i;
18
19 // 生成一条任务
20 Runnable runnable = new Runnable()
21 {
22 @Override
23 public void run()
24 {
25 try
26 {
27 System.out.println("into:" + no);
28 Thread.sleep(1000);
29 System.out.println("end:" + no);
30 }
31 catch (InterruptedException e)
32 {
33 e.printStackTrace();
34 }
35 }
36 };
37
38 // 将任务放到线程池中进行执行
39 executorService.execute(runnable);
40 }
41
42 // 所有任务执行完毕之后，关闭线程池
43 executorService.shutdown();
44
45 System.out.println("Thread Main End!");
46 }
47 }
newSingleThreadExecutor的使用
5、newCachedThreadPool的使用：
创建一个缓存池大小可根据需要伸缩的线程池，但是在以前构造的线程可用时可重用它们；对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能；调用execute将重用以前构造的线程（如果线程可用）；如果现有线程没有可用的，则创建一个新线程并添加到池中；终止并从缓存中移除那些已有60s未被使用的线程；因此，长时间保持空闲的线程池不会使用任何资源；
适用场景：是大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器；
1 /**
2 * newCachedThreadPool的使用
3 */
4 package thread05;
5
6 import java.util.concurrent.ExecutorService;
7 import java.util.concurrent.Executors;
8
9 public class NewCachedThreadPoolTest01
10 {
11 public static void main(String[] args)
12 {
13 ExecutorService executorService = Executors.newCachedThreadPool();
14
15 for(int i=0;i<10;i++)
16 {
17 final int no = i;
18
19 Runnable runnable = new Runnable()
20 {
21 @Override
22 public void run()
23 {
24 try
25 {
26 System.out.println("into:" + no);
27 Thread.sleep(1000L);
28 System.out.println("end:" + no);
29 }
30 catch (InterruptedException e)
31 {
32 e.printStackTrace();
33 }
34 }
35 };
36
37 executorService.execute(runnable);
38 }
39
40 executorService.shutdown();
41
42 System.out.println("Thread Main End!");
43 }
44 }
newCachedThreadPool的使用
6、newFixedThreadPool的使用：
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程；在任意点，在大多数nThreads线程会处于处理任务的活动状态；如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待；如果在关闭前的执行期间而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）；在某个线程被显式地关闭之前，池中的线程将一直存在；
适用场景：适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景；适用于负载比较重的服务器；
1 /**
2 * newFixedThreadPool的使用
3 */
4 package thread05;
5
6 import java.util.concurrent.ExecutorService;
7 import java.util.concurrent.Executors;
8
9 public class NewFixedThreadPool
10 {
11 public static void main(String[] args)
12 {
13 ExecutorService executorService = Executors.newFixedThreadPool(5);
14
15 for(int i=0;i<20;i++)
16 {
17 final int no = i;
18
19 Runnable runnable = new Runnable()
20 {
21 @Override
22 public void run()
23 {
24 try
25 {
26 System.out.println("into:" + no);
27 Thread.sleep(1000L);
28 System.out.println("end:" + no);
29 }
30 catch (InterruptedException e)
31 {
32 e.printStackTrace();
33 }
34 }
35 };
36
37 executorService.execute(runnable);
38 }
39
40 executorService.shutdown();
41
42 System.out.println("Thread Main End!");
43 }
44 }
newFixedThreadPool的使用
7、线程池的好处；
7.1、合理利用线程池能够带来4个好处：
（1）、降低资源消耗：通过重复利用已创建的线程，降低线程创建和销毁造成的消耗；
（2）、提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行；
（3）、提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控；
（4）、防止服务器过载，形成内存溢出，或者CPU耗尽；
7.2、线程池技术提高服务器程序的性能：
多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力；但如果对多线程应用不当，会增加对单个任务的处理时间；
7.3、线程池的应用范围：
（1）、需要大量的线程来完成任务，且完成任务的时间比较短：Web服务器完成网页请求这样的任务，使用线程池技术是非常合适的；因为单个任务小，而任务数量巨大；
8、线程池的工作机制及其原理：
9、自定义线程池和ExecutorService：
1 /**
2 * 自定义线程池
3 */
4 package thread05;
5
6 import java.util.concurrent.ArrayBlockingQueue;
7 import java.util.concurrent.BlockingQueue;
8 import java.util.concurrent.ThreadPoolExecutor;
9 import java.util.concurrent.TimeUnit;
10
11 public class ThreadPoolTest01
12 {
13 public static void main(String[] args)
14 {
15 // 创建等待队列
16 BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(20);
17 // 创建线程池，池中保存的线程数为3，允许的最大线程数为5
18 ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 50, TimeUnit.MILLISECONDS,bq);
19
20 // 创建七个任务
21 Runnable r1 = new RunnableTest3();
22 Runnable r2 = new RunnableTest3();
23 Runnable r3 = new RunnableTest3();
24 Runnable r4 = new RunnableTest3();
25 Runnable r5 = new RunnableTest3();
26 Runnable r6 = new RunnableTest3();
27 Runnable r7 = new RunnableTest3();
28
29 // 每个任务会在一个线程上执行
30 pool.execute(r1);
31 pool.execute(r2);
32 pool.execute(r3);
33 pool.execute(r4);
34 pool.execute(r5);
35 pool.execute(r6);
36 pool.execute(r7);
37
38 // 关闭线程池
39 pool.shutdown();
40 }
41 }
42
43 class RunnableTest3 implements Runnable
44 {
45 @Override
46 public void run()
47 {
48 System.out.println(Thread.currentThread().getName() + "正在执行...");
49
50 try
51 {
52 Thread.sleep(1000);
53 }
54 catch (InterruptedException e)
55 {
56 e.printStackTrace();
57 }
58 }
59
60 }
自定义线程池
10、线程池在工作中的错误使用：
（1）、分不清线程池是单例还是多对象：线程池一定要在合理的单例模式下才有效；就是说不要多次创建线程池；
（2）、线程池数量设置很大，请求过载：
（3）、注意死锁问题：
原文地址：https://www.cnblogs.com/kehuaihan/p/8460286.html