线程池基本实现

池化技术出现的原因

对于创建非常耗费资源的操作，常常使用池化的技术，比如线程池，连接池等。池化的核心思想是创建之后保存之前(放入池子)，下回要用先往池子里拿。不够了再创建，但往往会设置一个线程池的最大线程数量。

主体思路

1. 使用ThreadPool提供对外统一的编程界面，管理所有的执行器，并接受任务
2. THreadExecutor实现Runnable接口，对外提供接收任务的接口，在run中无限循环，执行任务，任务执行完后将自己放回线程池。
3. 这里的同步要控制好。

主要接口

• ThreadExecutor
  
  1. await()//等待任务
  2. assign(Object)//指派任务
  3. execute()//执行任务
  4. recycle()//把自己回收到pool中
  5. run()
     while (true) {
await();
execute();
recycle();
}
• ThreadPool
  
  1. getInstance()
  2. getInstance(int)
  3. execute(Object)//执行任务
  4. init()//初始化一定数量的执行器
  5. createOneExecutor()//创建一个执行器
  6. getExecutor() //获取执行器
  7. recycle(ThreadExecutor)//回收执行器

代码实现

代码的简单实现，里面还有很多细节没有搞好，比如怎么支持泛化操作的ThreadExecutor，在线程池中使用并发容器管理执行器，根据cpu核心数配置最大的线程池数量，在线程池忙的情况下如何维持一个队列，保证任务不丢(这个版本中是直接丢弃了)，如何实现异步调用，调用结束后给调用发一个结果，如果业务系统全部结束，如何结束线程池等等

package test.threadpool;

import java.util.Stack;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;

/**
 * 线程池
 * @author carey Mail:carey_yu@126.com
 * @version $Id: ThreadPool.java, v 0.1 2016年6月28日 下午7:38:54 Exp $
 */
public class ThreadPool {

    private static final Logger logger = Logger.getLogger("ffff");
    /**
     * 池子中可用的线程
     */
    private Stack<ThreadExecutor> available = new Stack<ThreadExecutor>();

    /**
     * 所有创建的线程数量
     */
    private AtomicInteger totalExecutorCnt = new AtomicInteger(0);

    /**
     * 线程池中最大的线程数
     */
    private final int maxExecutorCnt;

    private final static int DefaultMaxExecutorCnt = 10;

    /*
     * 私有构造方法
     */
    private ThreadPool(int maxExecutorCnt) {
        this.maxExecutorCnt = maxExecutorCnt;
        init();
    }

    /**
     * 获取线程池实例
     * 
     * @return
     */
    public static ThreadPool getInstance() {
        return new ThreadPool(DefaultMaxExecutorCnt);
    }

    /**
     * 获取线程池实例
     * 
     * @param maxExecutorCnt
     *            最大的线程池数量 如果超过默认的就是设置为默认的
     * @return
     */
    public static ThreadPool getInstance(int maxExecutorCnt) {
        return new ThreadPool(maxExecutorCnt > DefaultMaxExecutorCnt ? DefaultMaxExecutorCnt : maxExecutorCnt);
    }

    public void execute(Object o) {
        ThreadExecutor executor = getExecutor();
        System.out.println("getExecutor");
        if (null != executor) {
            executor.assign(o);
        } else {
            System.out.println("has no executor " + o);
        }

    }

    /**
     * 初始化,生成一定数量的执行器
     */
    private void init() {
        for (int i = 0; i < maxExecutorCnt; i++) {
            createOneExecutor();
        }

    }

    /**
     * 创建一个执行器，并启动执行器的线程
     * 
     * @return
     */
    private ThreadExecutor createOneExecutor() {
        ThreadExecutor executor = new ThreadExecutor(this);
        new Thread(executor, String.valueOf(totalExecutorCnt.get())).start();
        recycle(executor);
        totalExecutorCnt.incrementAndGet();
        return executor;
    }

    /**
     * totalExecutorCnt.intValue() < maxExecutorCnt 非线程安全 获取到一个执行器
     * <ul>
     * <li>如果当前的池子为空,但是totalCnt< Max，则创建一个返回。</li>
     * <li>返回null</li>
     * <ul>
     * 
     * @return
     */

    private ThreadExecutor getExecutor() {
        synchronized (available) {

            if (!available.isEmpty()) {
                return available.pop();
            }
        }
        if (totalExecutorCnt.intValue() < DefaultMaxExecutorCnt) {
            return createOneExecutor();
        }

        return null;
    }

    /**
     * 回收执行器
     * 
     * @param executor
     */
    public void recycle(ThreadExecutor executor) {
        synchronized (available) {

            available.push(executor);
        }
    }

    public static void main(String[] args) {
        ThreadPool pool = ThreadPool.getInstance(5);
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            // logger.error("", e);
        }
        for (int i = 0; i < 20; i++) {

            pool.execute(String.valueOf(i));
            System.out.println("main " + String.valueOf(i));
        }
    }
}



package test.threadpool;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * 执行器
 * @author carey Mail:carey_yu@126.com
 * @version $Id: ThreadExecutor.java, v 0.1 2016年6月28日 下午7:39:48 Exp $
 */
public class ThreadExecutor implements Runnable {

    private static Logger logger = Logger.getLogger("fff");
    /**
     * 需要被执行的对象，具体类型等待后续确定
     */
    private Object executeObj;

    private boolean isBuss = false;
    /**
     * 池子
     */
    private ThreadPool pool;

    public ThreadExecutor(ThreadPool threadPool) {
        this.pool = threadPool;
    }

    /**
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        logger.log(Level.INFO, this.toString() + "  starting");
        while (true) {
            await();
            execute();
            recycle();
        }
    }

    /**
     * 在这个方法中等待 获取需要被更新的对象
     */
    private synchronized void await() {
        while (!isBuss) {

            try {

                wait();
            } catch (InterruptedException e) {
                logger.log(Level.WARNING, e.getMessage());
            }
        }
        notifyAll();
    }

    /**
     * 指派需要被执行的对象 并且唤醒睡眠的线程
     * 
     * @param o
     */
    public synchronized void assign(Object o) {
        while (isBuss) {
            try {
                wait();
            } catch (InterruptedException e) {
                logger.log(Level.WARNING, e.getMessage());
            }
        }
        isBuss = true;
        executeObj = o;
        notifyAll();
    }

    /**
     * 执行业务操作
     */
    private void execute() {
        System.out.println(executeObj.toString());
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            // logger.error("", e);
            System.err.println(e.getMessage());
        }
    }

    /**
     * 回收给池子
     */
    private void recycle() {
        pool.recycle(this);
        System.out.println("recyle " + this.toString());

        isBuss = false;
        // 这里加一步notifyall是为了幻想之前被堵塞的生产者
        synchronized (this) {
            notifyAll();
        }
    }

}