# 线程池工具类（单例模式）

```
package com.ise.api.pool.threadpoolexecutor;

import java.util.concurrent.*;

/**
 * Created by daizhao.
 * User: tony
 * Date: 2018-4-20
 * Time: 10:06
 * info: 自定义线程池
 */
public class ThreadPoolConfig {

    private static ThreadPoolExecutor executor;

    /**返回可用处理器的Java虚拟机的数量*/
    private static int PROCESSORS = Runtime.getRuntime().availableProcessors();
    /**线程池中所保存的核心线程数，包括空闲线程*/
    private static int corePoolSize = 2;
    /**池中允许的最大线程数*/
    private static int maximumPoolSize = 6;
    /**线程池中的空闲线程所能持续的最长时间*/
    private static int keepAliveTime = 1;
    /**持续时间的单位*/
    private static TimeUnit timeUnit = TimeUnit.DAYS;
    /**队列容量*/
    private static int capacity = 50000;

    private static LinkedBlockingQueue<Runnable> queue;

    private static class SingletonClassInstance {
        private static final ThreadPoolConfig instance = new ThreadPoolConfig();
    }

    private ThreadPoolConfig(){}


    public static ThreadPoolConfig getInstance(){
        return SingletonClassInstance.instance;
    }

    public ThreadPoolExecutor init(){
        if(executor == null){
            queue = new LinkedBlockingQueue<Runnable>(capacity);
            executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, queue);
        }
        return executor;
    }

    public int getQueueSize() {
        return queue.size();
    }

    public boolean isQueueFull() {
        return queue.size() == capacity;
    }

    public boolean isBusy() {
        return executor.getPoolSize() == maximumPoolSize && isQueueFull();
    }

    public int getPoolSize() {
        return executor.getPoolSize();
    }

    public Future<?> submit(Callable t){
        return executor.submit(t);
    }

    public void shutdown(){
        executor.shutdown();
    }
}
```

测试类

```
package com.ise.api.pool.threadpoolexecutor;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * Created by daizhao.
 * User: tony
 * Date: 2018-4-20
 * Time: 10:25
 * info:
 */
public class RoomTask implements Runnable {

    @Override
    public void run() {
        System.out.println("roomTask测试");
    }


    public static void main(String[] args) {
        ThreadPoolConfig threadPoolConfig = ThreadPoolConfig.getInstance();
        ThreadPoolExecutor executor = threadPoolConfig.init();
        for (int i = 0; i < 10; i++) {
            executor.execute(new Thread(new RoomTask(), "TestThread".concat(""+i)));

        }
        System.out.println("线程队列大小为-->" + executor.getCorePoolSize());
        System.out.println("队列是否繁忙-->" + threadPoolConfig.isBusy());
        System.out.println("队列是否满员-->" + threadPoolConfig.isQueueFull());
        System.out.println("线程池数量-->" + threadPoolConfig.getPoolSize());
        System.out.println("线程池队列数量-->" + threadPoolConfig.getQueueSize());
        executor.shutdown();//一般不用关闭线程池,这里只是为了示例效果
    }
}
```

> 注意：如果是在WEB环境中使用一个共享的单例线程池，一般不用关闭线程池，是设置超时时间，自动回收的，否则显示调用shutdown()，会导致RejectedExecutionException异常


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://tuonioooo-notebook.gitbook.io/java-concurrent/di-er-zhang-java-xian-cheng-chi-yu-kuang-jia/xian-cheng-chi-gong-ju-lei.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.