• 【Java线程池ThreadPool（创建线程的第三种方式)】

    CSDN话题挑战赛第2期
    参赛话题：一起学Java

    线程池ThreadPool（创建线程的第三种方式)

    1、线程池的作用

    主要用于创建和管理若干个线程的一种容器，当我们需要执行任务时，可以从池中取出

    线程来执行，当执行完任务后，将线程返回到池中，避免频繁的去创建和销毁线程，从而

    节省空间，提升系统性能

    2、自定义线程池

    ThreadPoolExecutor pool=

    new ThreadPoolExecutor(

    核心线程数，

    最大线程数，

    超时（空闲，活跃）时间，

    超时的时间单位，

    任务队列，

    线程工厂，

    拒绝策略）；

    拒绝策略类型：

    * 1》AbortPolicy：拒绝执行新的任务，并抛出异常

    * 2》CallerRunsPolicy：如果线程池没有关闭，不使用线程池中的线程

    * 也不会加入到任务队列，而是让当前线程直接调用run（）方法来执行任务，

    * 如果线程池已关闭，则直接丢弃掉该任务不执行

    * 3》DiscardOldestPolicy: 如果线程池没有关闭，将任务队列中存放最久的任务

    * （队首元素）移除掉，并将新的任务加入到任务队列中，如果线程池已经关闭

    * 则直接丢弃掉该任务不执行

    * 4》DiscardPolicy:拒绝执行任务，但是不会抛异常

    3、jdk自带线程

    1》单线程线程池

    ExecutorService es=Executors.newSingleThreadExecutor()

    只有一个核心线程，不允许创建非核心线程；

    等上一个任务执行完了，才能执行下一个任务

    2》固定数量线程池

    ExecutorService es=Executors.newFixedThreadPool(int n);

    传入的参数既是核心线程又是最大线程，

    也就是不允许创建非核心线程

    3》可缓存线程池

    ExecutorService es=Executors.newCachedThreadPool();

    没有核心线程，所有线程均为非核心线程

    有多少任务就会创建多少个线程

    线程最大数量为integer.max_value，

    所有非核心线程空闲时间超过60S就会被回收

    4》周期性线程池

    ExecutorService es=Executors.newScheduledThreadPool(int n);

    自己指定核心线程数

    线程最大数量为integer.max_value

    超时时间为0

    任务队列为延迟队列

    4、线程池的常用方法

    1》execute（Runnable r)

    将任务对象交给线程池，线程池会自动取出空闲线程来执行任务，

    没有空闲线程就将任务加入到任务队列中，队列满了就触发拒绝策略

    2》shutdown()

    安全关闭线程池

    只有等到线程池中所有线程都执行完任务后才会关闭

    如果还有未执行完任务,当前方法会阻塞

    3》shutdownNow();

    立即关闭线程

    无论线程池中是否还有未执行完的额任务，都会立即关闭线程池

    会导致线程池还有未执行完的任务，返回这些未执行的线程

    周期性线程中的主要方法

    1》schedule（Runnable r,long delay, TimeUnit unit)

    延迟指定时间后来执行这个r任务

    2>scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);

    每间隔period指定的时间后来执行一次任务

    如果一个任务的执行时间超过了间隔时间，

    那么在一个任务执行完成红立即执行下一个任务，

    如果没有超过，那么就在指定间隔时间后执行下一个任务

    3》scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

    执行周期性任务

    在一个任务执行完成后，再间隔设置的时间后，

    再来执行下一个任务

    1. import java.util.Date;
    2. import java.util.concurrent.ArrayBlockingQueue;
    3. import java.util.concurrent.BlockingQueue;
    4. import java.util.concurrent.ExecutorService;
    5. import java.util.concurrent.Executors;
    6. import java.util.concurrent.RejectedExecutionHandler;
    7. import java.util.concurrent.ScheduledExecutorService;
    8. import java.util.concurrent.ThreadFactory;
    9. import java.util.concurrent.ThreadPoolExecutor;
    10. import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
    11. import java.util.concurrent.TimeUnit;
    12.  
    13. /*
    14.  * 线程池
    15.  */
    16. public class ThreadDemo16 {
    17. 	public static void main(String[] args) {
    18. 		//自定义线程池
    19. 		/**
    20. 		 * 参数解释：
    21. 		 * 1、corePoolSize：核心线程数
    22. 		 * 		线程池创建出来时就需要创建的线程数，线程池中需要保证最小数量线程
    23. 		 * 2、maximumPoolSize：最大线程数
    24. 		 * 		线程池中允许存在的最大线程数量
    25. 		 * 3、keepAliveTime：超时（空闲，活跃）时间
    26. 		 * 		非核心线程在指定时间内没有接收到新的任务，就会被销毁，
    27. 		 * 		如果调用了allowCoreThreadTimeOut()方法并且参数为true，
    28. 		 * 		那么超过指定时间后，核心线程也会被销毁
    29. 		 * 4、TimeUnit：keepAliveTime超时的时间单位
    30. 		 * 5、workQueue：任务队列
    31. 		 * 		需要线程池中的线程执行任务所存放的队列
    32. 		 * 6、threadFactory：线程工厂
    33. 		 * 		负责创建线程池中的线程
    34. 		 * 7、RejectedExecutionHandler:拒绝策略
    35. 		 * 		当线程池中所有线程都在执行任务，并且任务队列也是满负荷的情况下
    36. 		 * 		又有新的任务需要线程池来执行，就会触发拒绝策略
    37. 		 * 
    38. 		 * 拒绝策略类型：
    39. 		 * 1》AbortPolicy：拒绝执行新的任务，并抛出异常
    40. 		 * 2》CallerRunsPolicy：如果线程池没有关闭，不使用线程池中的线程
    41. 		 * 		也不会加入到任务队列，而是让当前线程直接调用run（）方法来执行任务，
    42. 		 * 		如果线程池已关闭，则直接丢弃掉该任务不执行
    43. 		 * 3》DiscardOldestPolicy:	如果线程池没有关闭，将任务队列中存放最久的任务
    44. 		 * 		（队首元素）移除掉，并将新的任务加入到任务队列中，如果线程池已经关闭
    45. 		 * 		则直接丢弃掉该任务不执行
    46. 		 * 4》DiscardPolicy:拒绝执行任务，但是不会抛异常
    47. 		 */
    48. //		ThreadPoolExecutor pool=
    49. //		new ThreadPoolExecutor(
    50. //				3,
    51. //                3,
    52. //                10,
    53. //                TimeUnit.SECONDS,
    54. //                new ArrayBlockingQueue(5),
    55. //                new ThreadFactory() {
    56. //					
    57. //					@Override
    58. //					public Thread newThread(Runnable r) {
    59. //						return new Thread(r);
    60. //					}
    61. //				},
    62. //               
    63. //               new AbortPolicy());
    64. //		
    65. //		//创建任务对象，并交给线程池执行
    66. //		//线程池会自动取出空闲线程来执行该任务
    67. //		pool.execute(new ThreadTask("A"));
    68. //		pool.execute(new ThreadTask("B"));
    69. //		pool.execute(new ThreadTask("C"));
    70. //		pool.execute(new ThreadTask("D"));
    71. //		pool.execute(new ThreadTask("E"));
    72. //		pool.execute(new ThreadTask("F"));
    73. //		pool.execute(new ThreadTask("G"));
    74. 		
    75. 		System.out.println("_____________________________________________");
    76. 		//系统提供的线程池
    77. 		/**
    78. 		 * 1、创建单个线程的线程池
    79. 		 * 		只有一个核心线程，不允许创建非核心线程；
    80. 		 * 		等上一个任务执行完了，才能执行下一个任务
    81. 		 * 
    82. 		 */
    83. //		ExecutorService es=
    84. //				Executors.newSingleThreadExecutor();
    85. 		/**
    86. 		 * 2、创建固定的数量线程的线程池
    87. 		 * 		传入的参数既是核心线程又是最大线程，
    88. 		 * 		也就是不允许创建非核心线程
    89. 		 */
    90. //		es=
    91. //				Executors.newFixedThreadPool(5);
    92. 		/**
    93. 		 * 3、创建可缓存线程池
    94. 		 * 		没有核心线程，所有线程均为非核心线程
    95. 		 * 		有多少任务就会创建多少个线程
    96. 		 * 		线程最大数量为integer.max_value，
    97. 		 *		所有非核心线程空闲时间超过60S就会被回收
    98. 		 */
    99. //		
    100. //		es=
    101. //				Executors.newCachedThreadPool();
    102. //		
    103. //		es.execute(new ThreadTask("A"));
    104. //		es.execute(new ThreadTask("B"));
    105. //		es.execute(new ThreadTask("C"));
    106. //		es.execute(new ThreadTask("D"));
    107. //		es.execute(new ThreadTask("E"));
    108. //		es.execute(new ThreadTask("F"));
    109. 		
    110. 		/**
    111. 		 * 4、周期性线程池
    112. 		 * 		自己指定核心线程数
    113. 		 * 		线程最大数量为integer.max_value
    114. 		 * 		超时时间为0
    115. 		 * 		任务队列为延迟队列
    116. 		 */
    117. 		ScheduledExecutorService es=
    118. 				Executors.newScheduledThreadPool(3);
    119. 		/**
    120. 		 * 指定延迟多长时间之后来执行任务
    121. 		 * 
    122. 		 */
    123. //		es.schedule(new Runnable() {
    124. //			
    125. //			@Override
    126. //			public void run() {
    127. //				System.out.println(new Date());
    128. //			}
    129. //		}, 5, TimeUnit.SECONDS);
    130. 		/**
    131. 		 * 2、执行周期性任务
    132. 		 * 参数解释
    133. 		 * 1》周期执行的任务
    134. 		 * 2》第一次执行任务的的延迟时间
    135. 		 * 3》两次任务执行时间的间隔时间
    136. 		 * 4》时间单位
    137. 		 * 
    138. 		 * 		如果一个任务的执行时间超过了间隔时间，
    139. 		 * 		那么在一个任务执行完成红立即执行下一个任务，
    140. 		 * 		如果没有超过，那么就在指定间隔时间后执行下一个任务
    141. 		 */
    142. 		System.out.println(new Date());
    143. 		es.scheduleAtFixedRate(new Runnable() {
    144. 			
    145. 			@Override
    146. 			public void run() {
    147. 				System.out.println(new Date());
    148. 			}
    149. 		}, 3, 1, TimeUnit.SECONDS);
    150. 		
    151. 		/**
    152. 		 * 3、执行周期性任务
    153. 		 *		 在一个任务执行完成后，再间隔设置的时间后，
    154. 		 * 		再来执行下一个任务
    155. 		 */
    156. 		
    157. //		System.out.println(new Date());
    158. //		es.scheduleWithFixedDelay(new Runnable() {
    159. //			
    160. //			@Override
    161. //			public void run() {
    162. //				try {
    163. //					Thread.sleep(1000);
    164. //				} catch (InterruptedException e) {
    165. //					e.printStackTrace();
    166. //				}
    167. //				System.out.println(new Date());
    168. //			}
    169. //		}, 3, 1, TimeUnit.SECONDS);
    170. 		//关闭线程池
    171. 		/*
    172. 		 * 安全关闭线程池
    173. 		 * 只有等到线程池中所有线程都执行完任务后才会关闭
    174. 		 * 如果还有未执行完任务,当前方法会阻塞
    175. 		 */
    176. //		es.shutdown();
    177. 		/*
    178. 		 * 立即关闭线程
    179. 		 * 无论线程池中是否还有未执行完的额任务，都会立即关闭线程池
    180. 		 * 会导致线程池还有未执行完的任务，返回这些未执行的线程
    181. 		 */
    182. //		pool.shutdownNow();
    183. 	}	
    184. }
    185.  
    186. //线程池需要执行的任务
    187. class ThreadTask implements Runnable{
    188. 	private String name;
    189. 	public ThreadTask(String name) {
    190. 		this.name=name;
    191. 	}
    192. 	@Override
    193. 	public void run() {
    194. 		System.out.println(
    195. 				Thread.currentThread().getName()+"线程正在执行"+name+"任务");
    196. 	}
    197. 	@Override
    198. 	public String toString() {
    199. 		return "名称为"+name+"任务";
    200. 	}
    201. 	
    202. }
    203.

  • 相关阅读:
    ThreadLocal底层源码分析
    SpringBoot-42-注册Web原生组件
    有用FPGA开发长光辰芯HR400BSI探测器的吗？有偿请教技术问题
    视频怎么添加水印？快来收好这些方法
    sqlserver 联表查询、子查询、窗口函数、聚合函数等概念与例子
    【产品运营】你真的懂B端大客户吗？来试试这8个棘手的需求问题
    这款信创FTP软件，可实现安全稳定的文件传输
    vue3 电子签名实现
    AI做题水平已超过CS博士？
    谷粒商城项目总结(一)-基础篇
  • 原文地址：https://blog.csdn.net/m0_72254454/article/details/126941236