java中创建线程池的方式一般有两种：

  1. package com.javaBase.LineDistancePond;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.ScheduledExecutorService;
  6. import java.util.concurrent.TimeUnit;
  8. /**
  9.  * 〈一句话功能简述〉;
  10.  * 〈功能详细描述〉
  11.  *
  12.  * @author jxx
  13.  * @see [相关类/方法]（可选）
  14.  * @since [产品/模块版本] （可选）
  15.  */
  16. public class TestThreadPoolExecutor {
  18.     public static void main(String[] args) {
  19.         //创建使用单个线程的线程池
  20.         ExecutorService es1 = Executors.newSingleThreadExecutor();
  21.         for (int i = 0; i < 10; i++) {
  22.             es1.submit(new Runnable() {
  23.                 @Override
  24.                 public void run() {
  25.                     System.out.println(Thread.currentThread().getName() + "正在执行任务");
  26.                 }
  27.             });
  28.         }
  29.         //创建使用固定线程数的线程池
  30.         ExecutorService es2 = Executors.newFixedThreadPool(3);
  31.         for (int i = 0; i < 10; i++) {
  32.             es2.submit(new Runnable() {
  33.                 @Override
  34.                 public void run() {
  35.                     System.out.println(Thread.currentThread().getName() + "正在执行任务");
  36.                 }
  37.             });
  38.         }
  39.         //创建一个会根据需要创建新线程的线程池
  40.         ExecutorService es3 = Executors.newCachedThreadPool();
  41.         for (int i = 0; i < 20; i++) {
  42.             es3.submit(new Runnable() {
  43.                 @Override
  44.                 public void run() {
  45.                     System.out.println(Thread.currentThread().getName() + "正在执行任务");
  46.                 }
  47.             });
  48.         }
  49.         //创建拥有固定线程数量的定时线程任务的线程池
  50.         ScheduledExecutorService es4 = Executors.newScheduledThreadPool(2);
  51.         System.out.println("时间：" + System.currentTimeMillis());
  52.         for (int i = 0; i < 5; i++) {
  53.             es4.schedule(new Runnable() {
  54.                 @Override
  55.                 public void run() {
  56.                     System.out.println("时间："+System.currentTimeMillis()+"--"+Thread.currentThread().getName() + "正在执行任务");
  57.                 }
  58.             },3, TimeUnit.SECONDS);
  59.         }
  60.         //创建只有一个线程的定时线程任务的线程池
  61.         ScheduledExecutorService es5 = Executors.newSingleThreadScheduledExecutor();
  62.         System.out.println("时间：" + System.currentTimeMillis());
  63.         for (int i = 0; i < 5; i++) {
  64.             es5.schedule(new Runnable() {
  65.                 @Override
  66.                 public void run() {
  67.                     System.out.println("时间："+System.currentTimeMillis()+"--"+Thread.currentThread().getName() + "正在执行任务");
  68.                 }
  69.             },3, TimeUnit.SECONDS);
  70.         }
  71.     }
  72. }

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) ;

corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

  1. TimeUnit.DAYS;               //天
  2. TimeUnit.HOURS;             //小时
  3. TimeUnit.MINUTES;           //分钟
  4. TimeUnit.SECONDS;           //秒
  5. TimeUnit.MILLISECONDS;      //毫秒
  6. TimeUnit.MICROSECONDS;      //微妙
  7. TimeUnit.NANOSECONDS;       //纳秒

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

  1. ArrayBlockingQueue
  2. LinkedBlockingQueue
  3. SynchronousQueue
  4. PriorityBlockingQueue
ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和SynchronousQueue。线程池的排队策略与BlockingQueue有关。

threadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程做些更有意义的事情，比如设置daemon和优先级等等
handler：表示当拒绝处理任务时的策略，有以下四种取值：

  1. 1、AbortPolicy：直接抛出异常。
  2. 2、CallerRunsPolicy：只用调用者所在线程来运行任务。
  3. 3、DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
  4. 4、DiscardPolicy：不处理，丢弃掉。
  5. 5、也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。
  1.  public static void test(int size) {
  2.         ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5, 20, 2, TimeUnit.SECONDS, new LinkedBlockingQueue<>(5));
  4.         for (int i = 0; i < size; i++) {
  5.             poolExecutor.execute(new DemoTask(i));
  8.             Console.log("poolSize:" + poolExecutor.getPoolSize());
  9.             Console.log("corePoolSize:" + poolExecutor.getCorePoolSize());
  10.             Console.log("maximumPoolSize:" + poolExecutor.getMaximumPoolSize());
  11.             Console.log("queue:" + poolExecutor.getQueue().size());
  12.             Console.log("completedTaskCount:" + poolExecutor.getCompletedTaskCount());
  13.             Console.log("largestPoolSize:" + poolExecutor.getLargestPoolSize());
  14.             Console.log("keepAliveTime:" + poolExecutor.getKeepAliveTime(TimeUnit.SECONDS));
  16.         }
  18.         poolExecutor.shutdown();
  19.     }
  21. class DemoTask implements Runnable {
  23.     private int taskNum;
  25.     public DemoTask(int taskNum) {
  26.         this.taskNum = taskNum;
  27.     }
  29.     @Override
  30.     public void run() {
  31.         Console.log(StringUtils.center("正在执行" + taskNum, 20, "="));
  33.         try {
  34.             Thread.sleep(2000);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.         Console.log(StringUtils.center("执行完毕" + taskNum, 20, "="));
  39.     }
  40. }

 

执行结果：

  1. =======正在执行0========
  2. poolSize:1
  3. corePoolSize:5
  4. maximumPoolSize:20
  5. queue:0
  6. completedTaskCount:0
  7. largestPoolSize:1
  8. keepAliveTime:2
  9. poolSize:2
  10. corePoolSize:5
  11. maximumPoolSize:20
  12. queue:0
  13. completedTaskCount:0
  14. =======正在执行1========
  15. largestPoolSize:2
  16. keepAliveTime:2
  17. poolSize:3
  18. corePoolSize:5
  19. maximumPoolSize:20
  20. =======正在执行2========
  21. queue:0
  22. completedTaskCount:0
  23. largestPoolSize:3
  24. keepAliveTime:2
  25. poolSize:4
  26. corePoolSize:5
  27. maximumPoolSize:20
  28. queue:0
  29. =======正在执行3========
  30. completedTaskCount:0
  31. largestPoolSize:4
  32. keepAliveTime:2
  33. poolSize:5
  34. corePoolSize:5
  35. =======正在执行4========
  36. maximumPoolSize:20
  37. queue:0
  38. completedTaskCount:0
  39. largestPoolSize:5
  40. keepAliveTime:2
  41. poolSize:5
  42. corePoolSize:5
  43. maximumPoolSize:20
  44. queue:1
  45. completedTaskCount:0
  46. largestPoolSize:5
  47. keepAliveTime:2
  48. poolSize:5
  49. corePoolSize:5
  50. maximumPoolSize:20
  51. queue:2
  52. completedTaskCount:0
  53. largestPoolSize:5
  54. keepAliveTime:2
  55. poolSize:5
  56. corePoolSize:5
  57. maximumPoolSize:20
  58. queue:3
  59. completedTaskCount:0
  60. largestPoolSize:5
  61. keepAliveTime:2
  62. poolSize:5
  63. corePoolSize:5
  64. maximumPoolSize:20
  65. queue:4
  66. completedTaskCount:0
  67. largestPoolSize:5
  68. keepAliveTime:2
  69. poolSize:5
  70. corePoolSize:5
  71. maximumPoolSize:20
  72. queue:5
  73. completedTaskCount:0
  74. largestPoolSize:5
  75. keepAliveTime:2
  76. poolSize:6
  77. corePoolSize:5
  78. maximumPoolSize:20
  79. queue:5
  80. completedTaskCount:0
  81. largestPoolSize:6
  82. keepAliveTime:2
  83. poolSize:7
  84. corePoolSize:5
  85. maximumPoolSize:20
  86. queue:5
  87. completedTaskCount:0
  88. largestPoolSize:7
  89. keepAliveTime:2
  90. =======正在执行11=======
  91. poolSize:8
  92. corePoolSize:5
  93. maximumPoolSize:20
  94. queue:5
  95. completedTaskCount:0
  96. =======正在执行12=======
  97. =======正在执行10=======
  98. largestPoolSize:8
  99. keepAliveTime:2
  100. poolSize:9
  101. corePoolSize:5
  102. =======正在执行13=======
  103. maximumPoolSize:20
  104. queue:5
  105. completedTaskCount:0
  106. largestPoolSize:9
  107. keepAliveTime:2
  108. poolSize:10
  109. corePoolSize:5
  110. maximumPoolSize:20
  111. =======正在执行14=======
  112. queue:5
  113. completedTaskCount:0
  114. largestPoolSize:10
  115. keepAliveTime:2
  116. poolSize:11
  117. corePoolSize:5
  118. maximumPoolSize:20
  119. queue:5
  120. =======正在执行15=======
  121. completedTaskCount:0
  122. largestPoolSize:11
  123. keepAliveTime:2
  124. poolSize:12
  125. corePoolSize:5
  126. maximumPoolSize:20
  127. queue:5
  128. completedTaskCount:0
  129. =======正在执行16=======
  130. largestPoolSize:12
  131. keepAliveTime:2
  132. poolSize:13
  133. corePoolSize:5
  134. maximumPoolSize:20
  135. =======正在执行17=======
  136. queue:5
  137. completedTaskCount:0
  138. largestPoolSize:13
  139. keepAliveTime:2
  140. poolSize:14
  141. corePoolSize:5
  142. maximumPoolSize:20
  143. queue:5
  144. =======正在执行18=======
  145. completedTaskCount:0
  146. largestPoolSize:14
  147. keepAliveTime:2
  148. poolSize:15
  149. corePoolSize:5
  150. maximumPoolSize:20
  151. =======正在执行19=======
  152. queue:5
  153. completedTaskCount:0
  154. largestPoolSize:15
  155. keepAliveTime:2
  156. =======执行完毕0========
  157. =======正在执行5========
  158. =======执行完毕1========
  159. =======执行完毕2========
  160. =======正在执行6========
  161. =======正在执行7========
  162. =======执行完毕4========
  163. =======正在执行8========
  164. =======执行完毕3========
  165. =======正在执行9========
  166. =======执行完毕13=======
  167. =======执行完毕12=======
  168. =======执行完毕10=======
  169. =======执行完毕11=======
  170. =======执行完毕15=======
  171. =======执行完毕16=======
  172. =======执行完毕14=======
  173. =======执行完毕19=======
  174. =======执行完毕18=======
  175. =======执行完毕17=======
  176. =======执行完毕5========
  177. =======执行完毕7========
  178. =======执行完毕6========
  179. =======执行完毕8========
  180. =======执行完毕9========

 

 

参考链接：Java线程池(一)

　　　　   Java线程池(二)

版权声明：本文为jxxblogs原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jxxblogs/p/11655670.html