java 线程池封装_线程池工具类的封装

了解更多学习 ThreadPoolExecutor类

ThreadPool.java

package com.tool.me.thread;

import java.util.Hashtable;

import java.util.Map;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public class ThreadPool {

private static Map map = new Hashtable<>();

private ThreadPoolExecutor executor;

/**

* 阻塞任务队列数

*/

private int wattingCount;

/**

* 线程池的名字，e.g:子系统的包名(com.tool.me)

*/

@SuppressWarnings("unused")

private String name;

/**

* 创建线程池

*

* @param name

* 线程池的名字，eg:子系统的包名(com.tool.me)

* @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

* 线程池中超过corePoolSize数目的空闲线程最大存活时间 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

* keepAliveTime时间单位 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.

*/

public ThreadPool(String name, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,

BlockingQueue workQueue) {

synchronized (map) {

this.name = name;

this.wattingCount = workQueue.size();

String key = buildKey(name, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue.size(), "#");

if (map.containsKey(key)) {

executor = map.get(key);

} else {

executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

map.put(key, executor);

}

}

}

/**

* 创建线程池

*

* @param name

* 线程池的名字，eg:子系统的包名(com.tool.me)

* @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

* 线程池中超过corePoolSize数目的空闲线程最大存活时间 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

* keepAliveTime时间单位 the time unit for the {@code keepAliveTime}

* argument

* @param wattingCount

* 阻塞任务队列数

*/

public ThreadPool(String name, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,

int wattingCount) {

synchronized (map) {

this.name = name;

this.wattingCount = (int) (wattingCount * 1.5);

String key = buildKey(name, corePoolSize, maximumPoolSize, keepAliveTime, unit, wattingCount, "#");

if (map.containsKey(key)) {

executor = map.get(key);

} else {

executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,

new LinkedBlockingQueue(this.wattingCount));

map.put(key, executor);

}

}

}

/**

* 组装map中的key

*

* @param name

* 线程池的名字，eg:子系统的包名(com.tool.me)

* @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

* 线程池中超过corePoolSize数目的空闲线程最大存活时间 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

* keepAliveTime时间单位 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 delimiter

* 分割符

*/

private String buildKey(String name, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,

int wattingCount, String delimiter) {

StringBuilder result = new StringBuilder();

result.append(name).append(delimiter);

result.append(corePoolSize).append(delimiter);

result.append(maximumPoolSize).append(delimiter);

result.append(keepAliveTime).append(delimiter);

result.append(unit.toString()).append(delimiter);

result.append(wattingCount);

return result.toString();

}

/**

* 添加任务到线程池(execute)中

* @param runnable the task to execute

*/

public void execute(Runnable runnable) {

checkQueneSize();

executor.execute(runnable);

}

private void checkQueneSize() {

while (getTaskSzie() >= wattingCount) {//如果线程池中的阻塞队列数 > wattingCount 则继续等待

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

/**

* Returns the number of elements in this collection. If this collection

* contains more than Integer.MAX_VALUE elements, returns

* Integer.MAX_VALUE.

*

* @return the number of elements in this collection

*/

public int getTaskSzie(){

return executor.getQueue().size();

}

}

ThreadPoolManager.java

package com.tool.me.thread;

import java.util.concurrent.TimeUnit;

public abstract class ThreadPoolManager {

private ThreadPool executor = null;

public ThreadPoolManager() {

if(executor == null) {

executor = new ThreadPool(getThreadPoolName(),corePoolSize(), maximumPoolSize(), keepAliveTime(), TimeUnit.SECONDS, wattingCount());

}

}

public void execute(Runnable runnable) {

executor.execute(runnable);

}

/**

* @return name

* 线程池名称 the String of pool name

*/

protected abstract String getThreadPoolName();

/**

* @return corePoolSize

* 核心线程池大小 the number of threads to keep in the pool, even if

* they are idle, unless {@code allowCoreThreadTimeOut} is set

*/

protected int corePoolSize(){

return 5;

}

/**

* @return maximumPoolSize

* 最大线程池大小 the maximum number of threads to allow in the pool

*/

protected int maximumPoolSize(){

return 10;

}

/**

* @return wattingCount

* 阻塞任务队列数

*/

protected int wattingCount(){

return 200000;

}

/**

* @return keepAliveTime

* 线程池中超过corePoolSize数目的空闲线程最大存活时间 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.

*/

protected long keepAliveTime(){

return 10;

}

}

子系统创建类 继承ThreadPoolManager，配置参数信息

ViThreadPoolManager.java

package com.tool.me.thread;

/**

* 当前类(子系统中定义的类)继承 ThreadPoolManager 类，设置相关参数

*/

public class ViThreadPoolManager extends ThreadPoolManager{

private static ThreadPoolManager threadPool = null;

public synchronized static ThreadPoolManager getInstance() {

if(threadPool == null) {

threadPool = new ViThreadPoolManager();

}

return threadPool;

}

@Override

protected String getThreadPoolName() {

return "com.tool.me.vi";

}

@Override

protected int corePoolSize() {

/**

* 代码 设置返回值

*/

return 10;

}

@Override

protected int maximumPoolSize() {

/**

* 代码 设置返回值

*/

return 20;

}

}

使用线程池 main

public static void main(String[] args) {

ViThreadPoolManager.getInstance().execute(new Runnable() {

@Override

public void run() {

io();

}

});

}