创建自己的多线程池类
本文通过ThreadGroup创建线程池类。
- 线程池介绍
- 自定义线程
- JDK自带线程池分析
线程池介绍
线程池就是预先创建一些工作线程，它们不断从工作队列中取出任务，然后完成任务。当工作线程执行完一个任务后，就会继续执行工作队列中的下一个任务。
线程池优点
- 减少了线程创建和销毁的次数，每个工作线程都可以一直被重用，能执行多个任务。
可以根据系统的承载能力，自由调整线程池中线程的数目。防止因为消耗过量资源而导致系统崩溃。
自定义线程
代码如下：
public class ThreadPool extends ThreadGroup{ private boolean isClosed = false; private LinkedList<Runnable> workQueue; private static int threadPoolID; private int threadID; public ThreadPool(int poolSize){ super("ThreadPool-"+(threadPoolID++)); setDaemon(true); workQueue = new LinkedList<>();//创建工作队列 for(int i=0;i<poolSize;i++){ new WorkThread().start();//创建并启动工作线程 } } /** * 获取task * @return * @throws InterruptedException */ protected synchronized Runnable getTask() throws InterruptedException { while (workQueue.size()==0){ if(isClosed){ return null; } wait(); //如果任务队列中没有任务，就等待任务 } return workQueue.removeFirst(); } /** * 关闭线程池 */ public synchronized void close(){ if(!isClosed){ isClosed = true; workQueue.clear();//清空任务队列 interrupt();//中断所有的工作线程，该方法继承ThreadGroup类 } } public void join(){ synchronized (this){ isClosed = true; notifyAll();//唤醒还在getTask()方法中等待任务的工作线程 } Thread[] threads = new Thread[activeCount()]; int count = enumerate(threads);//后的线程组中当前所有活着的工作线程 for(int i=0;i<count;i++){//等待所有工作线程结束 try { threads[i].join(); //等待工作线程运行结束 } catch (InterruptedException e) { e.printStackTrace(); } } } /** * 执行任务 * @param task */ public synchronized void execute(Runnable task){ if(isClosed){ throw new IllegalStateException(); } if(task!=null){ workQueue.add(task); notify();//唤醒正在getTask()方法中等待任务的工作线程 } } private class WorkThread extends Thread{ public WorkThread(){ super(ThreadPool.this,"WorkThread-"+(threadID++)); } @Override public void run() { while(!isInterrupted()){//判断线程是否被中断 Runnable task = null; try { task = getTask(); } catch (InterruptedException e) { e.printStackTrace(); } if(task==null){ return; } try { task.run(); }catch (Exception e){ e.printStackTrace(); } } } } }ThreadPool的测试类：
public class ThreadPoolTest {
public static void main(String[] args) {
int numTask = 10;
int poolSize = 4;
ThreadPool threadPool = new ThreadPool(poolSize);
for(int i=0;i<numTask;i++){
threadPool.execute(createTask(i));
}
threadPool.close();
}
private static Runnable createTask(final int i) {
return new Runnable() {
@Override
public void run() {
System.out.println("Task "+ i +":start");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task "+ i +":end");
}
};
}
}代码分析
在ThreadPool类中定义了一个LinkedList类型的workQueue成员变量，它表示工作队列，用来存放线程池要执行的任务，每个任务都是Runnable实例。ThreadPool的测试方法只需调用execute()方法，就能向ThreadPool提交任务。
在ThreadPool类的构造方法中，会创建并启动若干工作线程，工作线程的数目由参数poolSize决定。WorkThread表示工作线程，它是ThreadPool类的内部类。工作线程从工作队列中获取一个任务，接着执行该任务，然后再从工作队列中取出下一个任务并执行它，如此反复。
在execute()方法中：先判断该线程池是否已经关闭，如果关闭抛出IllegalStateException异常。如果没有关闭的话，将任务加到workQueue中，然后在唤醒getTask()方法中获取任务的线程。
getTask()方法实现：如果队列为空且线程池已关闭，则返回null。如果队列为空线程池没有关闭，则在此等待。如果队列中有任务则取出第一个将其返回。
- join()和close()方法都可用于关闭线程池。join()方法确保在关闭线程之前，工作线程把队列中的所有任务都执行完。而close()方法则情况队列，并中断所有工作线程。
测试类执行结果：
JDK自带线程池分析
测试JDK自带线程
代码如下：
public class ThreadPoolTest2 {
public static void main(String[] args) {
int poolSize = 4;
ExecutorService executorService = Executors.newFixedThreadPool(poolSize);
for(int i=0;i<10;i++) {
executorService.execute(createTask(i));
}
//executorService.shutdownNow(); //与自定义的线程池的close()方法类似
executorService.shutdown(); //与自定义的线程池的join()方法类似
}
private static Runnable createTask(final int taskId) {
return new Runnable() {
@Override
public void run() {
System.out.println("Task " + taskId + ":start");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + ":end");
}
};
}
}执行结果如下：
在上面代码中通过ExecutorService executorService = Executors.newFixedThreadPool(poolSize); 创建线程池，该方法时创建一个固定数目的线程池。
进入newFixedThreadPool 方法内，内容如下：
这个方法这是个幌子，在进入ThreadPoolExecutor类中 的另一个构造方法点击 this 进入 查看各个参数表示什么意思：
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
* pool
* @param keepAliveTime when the number of threads is greater than
* the core, this is the maximum time that excess idle threads
* will wait for new tasks before terminating.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
* @param threadFactory the factory to use when the executor
* creates a new thread
* @param handler the handler to use when execution is blocked
* because the thread bounds and queue capacities are reached
* @throws IllegalArgumentException if one of the following holds:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue}
* or {@code threadFactory} or {@code handler} is null
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {参数 corePoolSize ：核心线程池线程数目。
参数 maximumPoolSize ：最大线程池线程数。
参数 keepAliveTime ：空闲时间，如果线程池中的线程数大于corePoolSize的话，则这些多出来的线程在空闲时间超过keepAliveTime时将会销毁。
参数 unit ：keepAliveTime参数的单位。
参数 workQueue ：工作队列。工作队列支持三种策略：
- 直接提交。工作队列的默认选项是
SynchronousQueue一种阻塞队列。其中每个插入操作必须等待另一个线程的对应移除操作 ，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。 - 无界队列。使用无界队列（例如，不具有预定义容量的
LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙于新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列； - 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如
ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致降低吞吐量。
参数 threadFactory ：线程工厂。使用 ThreadFactory 创建新线程。如果没有另外说明，则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。
参数 handler ：被拒绝的任务处理的handler。当 Executor 已经关闭，并且 Executor 将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法 execute(java.lang.Runnable) 中提交的新任务将被 拒绝。在默认的 ThreadPoolExecutor.AbortPolicy 中，处理程序遭到拒绝将抛出运行时异常 RejectedExecutionException。
类图
Executor、ExecutorService、Executors 三个类直接的关系:
总结：
其实我们自己定义的线程池也是借鉴JDK自带的线程池的。在创建一个线程池的时候，都有这几个必要元素：线程池大小、线程存活时间、线程工厂、工作队列、任务拒绝处理方法。
在使用JDK的线程池中，我们只用到两个类，一个是Executors 和ExecutorService 这个是接口。其实还有一个接口很重要，因为它是execute()方法的申明类，也是ExecutorService 的父接口，就是 Executor 。这三个类各司其职：
| 类名 | 作用 |
|---|---|
| Executor | 线程池类，它的execute()方法用来执行Runnable类型的任务。 |
| ExecutorService | 是Executor的子接口，申明了一些管理线程池的方法。比如shutdow() |
| Executors | Executors包含一些静态方法，它主要负责创建各种类型的ExecutorService实例。 |
欢迎关注微信公众号 在路上的coder 每天分享优秀的Java技术文章！
扫描二维码关注：
1264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
