Java学习之自定义线程池
作者：互联网
最近面试中，经常会被问到线程池的知识。总感觉自己回答的不够全面。借助资料整理总结一下线程池
Java自带的线程池
要看自定义线程池，需要先看一下线程执行框架 java.util.concurrent.Executors 这个类，这个类扮演的是线程工厂的角色。
通过这个类创建线程池的方法主要有以下四种：
ExecutorService newCachedThreadPool() 返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数数量，若有任务，则创建线程，若无线程则不创建线程，若无线程则在60s后进行线程回收。
ExecutorService newFixedThreadPool (int) 返回一个固定数量的线程池，该方法的线程数始终不变，当有一个线程提交时，若线程池空闲，即立即执行，若没有则会被在一个任务队列中等待有空闲的线程去执行
ExecutorService newSingleThreadExecutor() 返回一个执行器，它在一个单个的线程中依次执行各个任务。
ScheduledExecutorService newSingleThreadScheduledExecutor() 创建的是一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行
ThreadPoolExecutor
自带的线程池中线程的创建均是使用了java.util.concurrent.ThreadPoolExecutor类，在这个类的构造器中：
可以用以下代码表示，主要参数有：
1 public ThreadPoolExecutor(int corePoolSize, //核心线程数
2 int maxNumberSize, //最大线程数
3 long keepAliveTime, //连接时间数
4 TimeUnit unit, //时间单位
5 BlockingQueue<Runnable> paramBlockingQueue, //处理线程队列
6 RejectedExecutionHandler RejectedExecutionHandler //拒绝处理器
7 ) {
corePoolSize:指定了线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去；
maxNumberPoolSize:指定了线程池中的最大线程数量，这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；
keepAliveTime:当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；
unit:keepAliveTime的单位
workQueue:任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；
threadFactory:线程工厂，用于创建线程，一般用默认即可；
RejectedExecutionHandler :拒绝策略；当任务太多来不及处理时，如何拒绝任务；
自定义线程池demo
创建一个线程类:
1 package com.ssc.demo;
2
3 public class MyTask implements Runnable {
4
5 private int taskId;
6 private String taskName;
7
8 public MyTask(int taskId, String taskName){
9 this.taskId = taskId;
10 this.taskName = taskName;
11 }
12
13 public int getTaskId() {
14 return taskId;
15 }
16
17 public void setTaskId(int taskId) {
18 this.taskId = taskId;
19 }
20
21 public String getTaskName() {
22 return taskName;
23 }
24
25 public void setTaskName(String taskName) {
26 this.taskName = taskName;
27 }
28
29 @Override
30 public void run() {
31 try {
32 System.out.println("run taskId =" + this.taskId);
33 Thread.sleep(5*1000);
34 } catch (InterruptedException e) {
35 e.printStackTrace();
36 }
37 }
38
39 public String toString(){
40 return Integer.toString(this.taskId);
41 }
42
43 }
插入拒绝处理类：
1 package com.ssc.demo;
2
3 import java.util.concurrent.RejectedExecutionHandler;
4 import java.util.concurrent.ThreadPoolExecutor;
5
6 public class MyRejected implements RejectedExecutionHandler{
7
8
9 public MyRejected(){
10 }
11
12 @Override
13 public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
14 System.out.println("自定义处理..");
15 System.out.println("当前被拒绝任务为：" + r.toString());
16 }
17
18 }
使用有界队列自定义线程池时：
1 package com.ssc.demo;
2
3 import java.util.concurrent.ArrayBlockingQueue;
4 import java.util.concurrent.ThreadPoolExecutor;
5 import java.util.concurrent.TimeUnit;
6
7
8
9 public class UseThreadPoolExecutor1 {
10
11
12 public static void main(String[] args) {
13 /**
14 * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
15 * 若大于corePoolSize，则会将任务加入队列，
16 * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
17 * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
18 *
19 */
20 ThreadPoolExecutor pool = new ThreadPoolExecutor(
21 1, //coreSize
22 2, //MaxSize
23 60, //60
24 TimeUnit.SECONDS,
25 new ArrayBlockingQueue<Runnable>(3) //指定一种队列 （有界队列）
26 //new LinkedBlockingQueue<Runnable>()
27 , new MyRejected()
28 //, new DiscardOldestPolicy()
29 );
30
31 MyTask mt1 = new MyTask(1, "任务1");
32 MyTask mt2 = new MyTask(2, "任务2");
33 MyTask mt3 = new MyTask(3, "任务3");
34 MyTask mt4 = new MyTask(4, "任务4");
35 MyTask mt5 = new MyTask(5, "任务5");
36 MyTask mt6 = new MyTask(6, "任务6");
37
38 pool.execute(mt1);
39 pool.execute(mt2);
40 pool.execute(mt3);
41 pool.execute(mt4);
42 pool.execute(mt5);
43 pool.execute(mt6);
44
45 pool.shutdown();
46
47 }
48 }
运行该类时。效果如下
使用无界队列自定义线程池时
1 package com.ssc.demo;
2
3 import java.util.concurrent.ArrayBlockingQueue;
4 import java.util.concurrent.BlockingQueue;
5 import java.util.concurrent.ExecutorService;
6 import java.util.concurrent.LinkedBlockingQueue;
7 import java.util.concurrent.ThreadPoolExecutor;
8 import java.util.concurrent.TimeUnit;
9 import java.util.concurrent.atomic.AtomicInteger;
10
11 public class UseThreadPoolExecutor2 implements Runnable{
12
13 private static AtomicInteger count = new AtomicInteger(0);
14
15 @Override
16 public void run() {
17 try {
18 int temp = count.incrementAndGet();
19 System.out.println("任务" + temp);
20 Thread.sleep(2000);
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 }
24 }
25
26 public static void main(String[] args) throws Exception{
27 //System.out.println(Runtime.getRuntime().availableProcessors());
28 BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
29 ExecutorService executor = new ThreadPoolExecutor(
30 5, //core
31 10, //max
32 120L, //2fenzhong
33 TimeUnit.SECONDS,
34 queue);
35
36 for(int i = 0 ; i < 20; i++){
37 executor.execute(new UseThreadPoolExecutor2());
38 }
39 Thread.sleep(1000);
40 System.out.println("queue size:" + queue.size()); //10
41 Thread.sleep(2000);
42 }
43
44
45 }
允许结果为：
该项目主要参考对 北京尚学堂的白鹤翔视频
java线程池ThreadPoolExecutor类使用详解
标签：java,自定义,util,线程,new,Java,MyTask,public 来源： https://www.cnblogs.com/songlove/p/14972830.html