线程池（1）—— 线程池管理

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sinosoft</groupId>
    <artifactId>ThreadPoolManage</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- jar 包依赖 -->
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

线程池管理：

package com.sinosoft;


import java.util.concurrent.*;

/**
 * @author xushuyi 2017/3/12.
 */
public class ThreadPoolManage {

    /**
     * 线程池维护线程的最少数量
     */
    private final static int CORE_POOL_SIZE = 10;
    /**
     * 线程池维护线程的最大数量
     */
    private final static int MAX_POOL_SIZE = 5000;
    /**
     * 线程池维护线程所允许的空闲时间
     */
    private final static int KEEP_ALIVE_TIME = 0;
    /**
     * 线程池所使用的缓冲队列大小
     */
    private final static int WORK_QUEUE_SIZE = 100;

    /**
     * 线程管理对象
     */
    private static ThreadPoolManage tpm = null;

    /**
     * 消息缓冲队列
     */
    private static final BlockingQueue<Object[]> QUEUE = new LinkedBlockingQueue<Object[]>();

    /**
     * 将任务放置队列 等待执行
     */
    final RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            // 将数组任务对象加入到消息队列中
            if (!isEmpty(((ThreadRun) r).getObjArr())) {
                Object[] taskArr = (Object[]) ((ThreadRun) r).getObjArr();
                for (int i = 0; i < taskArr.length; i++) {
                    System.out.println("将数组集合任务对象：" + taskArr[i] + " 放入队列中重新等待执行");
                }
                QUEUE.offer((Object[]) ((ThreadRun) r).getObjArr());
            }
        }
    };

    /**
     * 创建线程池
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME,
            TimeUnit.SECONDS, new ArrayBlockingQueue(WORK_QUEUE_SIZE), this.handler);

    /**
     * 调度线程池
     */
    final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(100);

    /**
     * 访问消息缓存的调度线程
     * 查看是否有待定请求，如果有，则创建一个新的AccessDBThread，并添加到线程池中
     */
    final Runnable accessBufferThread = new Runnable() {
        @Override
        public void run() {
            if (hasMoreAcquire()) {
                System.out.println("-》将缓存队列中的任务计划加入到线程池中...");
                Object[] obj = QUEUE.poll();
                Runnable task = new ThreadRun(obj);
                threadPool.execute(task);
            }
        }
    };

    /**
     * 开始执行调度线程池任务
     */
    @SuppressWarnings("rawtypes")
    final ScheduledFuture taskHandler = scheduler.scheduleAtFixedRate(this.accessBufferThread, 0, 1, TimeUnit.SECONDS);

    /**
     * 获取线程池管理对象
     *
     * @return ThreadPoolManage
     */
    public static ThreadPoolManage newInstance() {
        if (isEmpty(tpm)) {
            tpm = new ThreadPoolManage();
        }
        return tpm;
    }

    /**
     * 线程池构造器
     */
    private ThreadPoolManage() {
    }

    /**
     * 判断队列是否还有缓存任务
     *
     * @return Boolean
     */
    private boolean hasMoreAcquire() {
        return (!QUEUE.isEmpty());
    }

    /**
     * 添加任务 数组
     *
     * @param obj 任务
     */
    public void addTask(Object[] obj) {
        Runnable task = new ThreadRun(obj);
        threadPool.execute(task);
    }

    /**
     * 判断一个对象是否为空
     *
     * @param obj
     * @return
     */
    public static boolean isEmpty(Object obj) {
        if (("").equals(obj) || null == obj || "null".equals(obj) || obj.equals(null)) {
            return true;
        }
        return false;
    }

}

线程池任务调度执行：

package com.sinosoft;

import com.alibaba.fastjson.JSONObject;

/**
 * @author xushuyi 2017/3/12.
 */
public class ThreadRun implements Runnable {

    /**
     * 需要执行的数组任务对象
     */
    private Object[] objArr;

    /**
     * 构造器赋值
     *
     * @param objArr 任务对象
     */
    ThreadRun(Object[] objArr) {
        this.objArr = objArr;
    }

    /**
     * 开始执行
     */
    @Override
    public void run() {
        if (!isEmpty(objArr) && objArr.length > 0) {
            for (int i = 0; i < objArr.length; i++) {
                JSONObject taskJson = (JSONObject) JSONObject.toJSON(objArr[i]);
                String taskCode = (String) taskJson.get("taskCode");
                if ("001".equals(taskCode)) {
                    System.out.println("Object[] Start Task: " + taskJson.toString() + " Over.");
                }
            }
        }
    }

    /**
     * 获取要执行的任务对象
     *
     * @return 任务对象
     */
    public Object getObjArr() {
        return objArr;
    }

    /**
     * 判断一个对象是否为空
     *
     * @param obj
     * @return
     */
    public static boolean isEmpty(Object obj) {
        if (("").equals(obj) || null == obj || "null".equals(obj) || obj.equals(null)) {
            return true;
        }
        return false;
    }

}

测试主类：

package com.sinosoft;

import com.alibaba.fastjson.JSONObject;

import java.util.HashMap;
import java.util.Map;

/**
 * @author xushuyi 2017/3/12.
 */
public class ThreadPoolTest {

    /**
     * 获取线程池对象实例
     */
    ThreadPoolManage tpm = ThreadPoolManage.newInstance();

    /**
     * 开始调用线程池
     *
     * @param obj 数据对象
     */
    public void addTask(Object[] obj) {
        tpm.addTask(obj);
    }

    /**
     * 测试主方法
     *
     * @param args
     */
    public static void main(String[] args) {
        // 开始创建线程任务
        Object[] objArr = null;
        Integer num = 20;
        for (int i = 0; i <= num; i++) {
            Map<String, Object> taskMap = new HashMap();
            taskMap.put("taskCode", "001");
            taskMap.put("taskData", new Object[]{"xushuyi_" + i});
            objArr = new Object[]{JSONObject.toJSON(taskMap)};
            new ThreadPoolTest().addTask(objArr);
        }

    }
}

参考资料：

http://www.cnblogs.com/molao-doing/articles/4445045.html

转载于:https://www.cnblogs.com/xushuyi/articles/9076542.html