线程池的原理及实现

Posted 2022-12-07 z_fishLong

1.Java类库中提供的线程池简介：

     java提供的线程池更加强大，相信理解线程池的工作原理，看类库中的线程池就不会感到陌生了。

2、线程池简介：
    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。    
    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
                一个线程池包括以下四个基本组成部分：
                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
                
    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
    线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
    假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

    代码实现中并没有实现任务接口，而是把Runnable对象加入到线程池管理器（ThreadPool），然后剩下的事情就由线程池管理器（ThreadPool）来完成了

 

[java]

  view plain copy

1. package mine.util.thread;  
2.   
3. import java.util.LinkedList;  
4. import java.util.List;  
5.   
6. /** 
7.  * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息 
8.  */  
9. public final class ThreadPool   
10.     // 线程池中默认线程的个数为5  
11.     private static int worker_num = 5;  
12.     // 工作线程  
13.     private WorkThread[] workThrads;  
14.     // 未处理的任务  
15.     private static volatile int finished_task = 0;  
16.     // 任务队列，作为一个缓冲,List线程不安全  
17.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
18.     private static ThreadPool threadPool;  
19.   
20.     // 创建具有默认线程个数的线程池  
21.     private ThreadPool()   
22.         this(5);  
23.       
24.   
25.     // 创建线程池,worker_num为线程池中工作线程的个数  
26.     private ThreadPool(int worker_num)   
27.         ThreadPool.worker_num = worker_num;  
28.         workThrads = new WorkThread[worker_num];  
29.         for (int i = 0; i < worker_num; i++)   
30.             workThrads[i] = new WorkThread();  
31.             workThrads[i].start();// 开启线程池中的线程  
32.           
33.       
34.   
35.     // 单态模式，获得一个默认线程个数的线程池  
36.     public static ThreadPool getThreadPool()   
37.         return getThreadPool(ThreadPool.worker_num);  
38.       
39.   
40.     // 单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数  
41.     // worker_num<=0创建默认的工作线程个数  
42.     public static ThreadPool getThreadPool(int worker_num1)   
43.         if (worker_num1 <= 0)  
44.             worker_num1 = ThreadPool.worker_num;  
45.         if (threadPool == null)  
46.             threadPool = new ThreadPool(worker_num1);  
47.         return threadPool;  
48.       
49.   
50.     // 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
51.     public void execute(Runnable task)   
52.         synchronized (taskQueue)   
53.             taskQueue.add(task);  
54.             taskQueue.notify();  
55.           
56.       
57.   
58.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
59.     public void execute(Runnable[] task)   
60.         synchronized (taskQueue)   
61.             for (Runnable t : task)  
62.                 taskQueue.add(t);  
63.             taskQueue.notify();  
64.           
65.       
66.   
67.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
68.     public void execute(List<Runnable> task)   
69.         synchronized (taskQueue)   
70.             for (Runnable t : task)  
71.                 taskQueue.add(t);  
72.             taskQueue.notify();  
73.           
74.       
75.   
76.     // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁  
77.     public void destroy()   
78.         while (!taskQueue.isEmpty()) // 如果还有任务没执行完成，就先睡会吧  
79.             try   
80.                 Thread.sleep(10);  
81.              catch (InterruptedException e)   
82.                 e.printStackTrace();  
83.               
84.           
85.         // 工作线程停止工作，且置为null  
86.         for (int i = 0; i < worker_num; i++)   
87.             workThrads[i].stopWorker();  
88.             workThrads[i] = null;  
89.           
90.         threadPool=null;  
91.         taskQueue.clear();// 清空任务队列  
92.       
93.   
94.     // 返回工作线程的个数  
95.     public int getWorkThreadNumber()   
96.         return worker_num;  
97.       
98.   
99.     // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成  
100.     public int自己实现一个简单的线程池

     线程池的工作原理及使用示例

     java线程池原理及实现方式

     java高性能编程基础 - 线程池的应用及实现原理

     线程池原理线程池的原理及实现

     线程池的原理及实现