Lmxy1990 ' Blog

Java 自定义线程池

发表于 | 更新于 | 分类于 |

自定义线程池的逻辑:

指定核心线程数,最大线程数,线程执行的最长时间,线程指定最长时间的单位,线程执行任务的缓存队列,线程工厂.
代码:

自定义线程工厂:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyThreadFactory implements ThreadFactory {

    //线程优先级
    private int priority = 5;
    //是否是守护线程
    private boolean daemon = false;
    private String name = "自定义线程";
    private ClassLoader classLoader;
    private UncaughtExceptionHandler uncaughtExceptionHandler;

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName(this.name);
        thread.setPriority(this.priority);
        thread.setDaemon(this.daemon);
        thread.setContextClassLoader(this.classLoader);
        thread.setUncaughtExceptionHandler(this.uncaughtExceptionHandler);
        System.out.println("通过线程工厂开始执行线程:"+this.name);
        return thread;
    }
}

自定义线程池:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class ThreadPool {


    public static void main(String[] args) {

        //自定义缓冲队列
        LinkedBlockingQueue<Runnable> linkedBlockingDeque = new LinkedBlockingQueue<>() ;

        //自定义线程工厂
        ThreadFactory threadFactory = new MyThreadFactory() ;

        //自定义线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,10,10, TimeUnit.MINUTES,linkedBlockingDeque,threadFactory) ;

        //通过程工厂执行任务
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.execute(() -> {
                for (int j = 0; j <100000000; j++) {
                    int div = Math.floorDiv(++j, j * j);
//                    System.out.println(div);
                }
                System.out.println("线程启动") ;
            });
            int activeCount = threadPoolExecutor.getActiveCount();
            System.out.println("当前进行中的线程数:" +activeCount);
            System.out.println("当前队列中的缓存数:" +linkedBlockingDeque.size());
        }
        //关闭线程池
        threadPoolExecutor.shutdown();
    }

}

执行输出结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
通过线程工厂开始执行线程:自定义线程
线程名:自定义线程
当前进行中的线程数:1
当前队列中的缓存数:0
通过线程工厂开始执行线程:自定义线程
线程名:自定义线程
当前进行中的线程数:2
当前队列中的缓存数:0
通过线程工厂开始执行线程:自定义线程
线程名:自定义线程
当前进行中的线程数:3
当前队列中的缓存数:0
通过线程工厂开始执行线程:自定义线程
线程名:自定义线程
当前进行中的线程数:4
当前队列中的缓存数:0
通过线程工厂开始执行线程:自定义线程
线程名:自定义线程
当前进行中的线程数:5
当前队列中的缓存数:0
当前进行中的线程数:5
当前队列中的缓存数:1
当前进行中的线程数:5
当前队列中的缓存数:2
当前进行中的线程数:5
当前队列中的缓存数:3
当前进行中的线程数:5
当前队列中的缓存数:4
当前进行中的线程数:5
当前队列中的缓存数:5
当前进行中的线程数:5
当前队列中的缓存数:6
当前进行中的线程数:5
当前队列中的缓存数:7
当前进行中的线程数:5
当前队列中的缓存数:8
当前进行中的线程数:5
当前队列中的缓存数:9
当前进行中的线程数:5
当前队列中的缓存数:10
当前进行中的线程数:5
当前队列中的缓存数:11
当前进行中的线程数:5
当前队列中的缓存数:12
当前进行中的线程数:5
当前队列中的缓存数:13
当前进行中的线程数:5
当前队列中的缓存数:14
当前进行中的线程数:5
当前队列中的缓存数:15
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动
线程启动

结果分析:

  1. 任务启动 -> 线程工厂创建该线程 -> 线程池判断当前线程执行数量 -> 线程等待 -> 加入缓冲队列.

  2. 任务启动 -> 线程工厂创建该线程 -> 线程池判断当前线程执行数量 -> 线程执行

  3. 线程池当前执行任务数少于最大任务数 -> 缓冲队列FIFO 获取任务.

End

坚持原创技术分享，您的支持将鼓励我继续创作！