异步线程池的实现（一）-------具体实现方法

本篇是这个内容的第一篇，主要是写:遇到的问题，和自己摸索实现的方法。后面还会有一篇是总结性地写线程池的相关内容（偏理论的）。

一、背景介绍

    朋友的项目开发到一定程度之后，又遇到了一些问题：在某些流程中的一些节点，由于是串联执行的。上一步要等下一步执行完毕；或者提交数据之后要等待后台其他系统处理完成之后，才能返回结果。这样就会导致，请求发起方不得不一直等待结果，用户体验很不好；从项目优化来说，模块与模块之间构成了强耦合，这也是不利于以后扩展的，更不用说访问量上来之后，肯定会抓瞎的问题。所以，我就着手开始，利用异步线程池来解决这个问题。

    刚开始的时候，我准备只是在节点处另外起线程去执行异步操作。但是，考虑到以后的扩展，同时利用“池化”技术，更加高效地重复利用线程，节省资源。在这里就选定了，使用线程池的方法。

二、实现步骤

     实现总共分为四步：

第一步，在启动服务的时候初始化线程池；

第二步，建立有队列的线程池；

第三步，将业务逻辑方法与线程池联系起来；

第四步，调整原有代码逻辑结构，将可以异步的操作放入第三步的业务逻辑方法，并将请求放入线程池的队列中，等待执行。

三、具体实现

首先，第一步我们在web项目的起源之处web.xml中加入这么一行

<listener>

                   <listener-class>com.jptec.kevin.thread.listener.InitThreadPoolListener</listener-class>

</listener>

这里的路径实际上就是，在启动项目之后，会加载的初始化函数。这个函数主要的作用就是：将线程池启动起来。实现代码如下：

public class InitThreadPoolListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {

        new TestThreadPool().runThread();
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
    }

}

好了，第一步就算完工了。

    然后，我们开始第二步，建立有队列的线程池（这里有很多，理论上的内容，会放在第二篇中详细说）。在这里主要是，定义了一个ArrayBlockingQueue队列（先进先出，有限阻塞），使用Executor定义了一个线程池。具体代码如下:

public class TestThreadPool {

    protected final static Logger log = LoggerFactory.getLogger(TestThreadPool.class);

    // 线程休眠时间(秒)
    // 存放需要发送的信息
    public static BlockingQueue<Runnable> addressBqueue = new ArrayBlockingQueue<Runnable>(
                10000);
        
    public static final ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 200, 25, TimeUnit.SECONDS,
            addressBqueue);

    public TestThreadPool() {
    }
    

    public void runThread() {

        try {
            executor.prestartCoreThread();
            log.info("队列大小:" + executor.getQueue().size());

        } catch (Exception e) {
            log.error("启动子线程异常", e);
        }

    }

}

    完成第二步之后，我们继续第三步。我们有了线程池，那么实际代码如何将请求放入其中，并等待执行呢。于是，这里分为两个类，一个是负责业务代码中调用的，负责向队列中插入请求，一个是单个线程的实现类。具体实现如下：

插入请求实现：

/**
 * 线程队列
 */
public class TestQueue {
    protected final static Logger log = LoggerFactory.getLogger(TestQueue.class);

    public static boolean put(String userId,String tradeId, String amount, String flag, String term) {
            log.debug("添加入队列开始... 额度申请用户tradeId=[{}]", tradeId);
            try {
                TestThreadPool.executor.execute(new TestThread( tradeId, amount,  flag, term, userId));
            log.debug("添加入队列结束...");
        } catch (Exception e) {
            log.error("添加入队列异常...", e);
            return false;
        }
        return true;
    }

}

单个线程实现（第八行的引用在下文细说）：

/**
 * 发送信息线程处理类
 */
public class TestThread implements Runnable {

    protected final static Logger log = LoggerFactory.getLogger(TestThread.class);

    private TradeService tradeService = (TradeService) SpringHandle.getBean("tradeService");

    String tradeId;
    String amount;
    String flag;
    String term;
    String userId;
    /** 
     * <p>Title: </p>
     * <p>Description: </p>
     * @param tradeId
     * @param amount
     * @param flag
     * @param term
     * @param userId 
     */ 
    public TestThread(String tradeId, String amount, String flag, String term,
            String userId) {
        super();
        this.tradeId = tradeId;
        this.amount = amount;
        this.flag = flag;
        this.term = term;
        this.userId = userId;
    }
    @Override
    public void run() {
        log.info("线程开始tradeId={}", tradeId);
        log.info("线程名:={}", Thread.currentThread().getId());
        log.info("队列大小:" + TestThreadPool.executor.getPoolSize() + ","
                + TestThreadPool.executor.getCompletedTaskCount());
        putTradeConfirm(userId,tradeId, amount, flag, term);
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void putTradeConfirm(String userId,String tradeId, String amount, String flag, String term) {

        tradeService.getMatchFundInfo(userId,amount, tradeId, flag, term);
    }
}

这里需要注意的是，我需要获得一个Service的实例来调用具体的方法。但是，注释的方法不起作用，于是在朋友的帮助下，使用了辅助类。具体实现如下：

@Component
public final class SpringHandle implements BeanFactoryPostProcessor {

    private static ConfigurableListableBeanFactory beanFactory; // Spring应用上下文环境

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        SpringHandle.beanFactory = beanFactory;
    }

    /**
     * 获取对象
     * 
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws org.springframework.beans.BeansException
     * 
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     * 
     * @param clz
     * @return
     * @throws org.springframework.beans.BeansException
     * 
     */
    public static <T> T getBean(Class<T> clz) throws BeansException {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     * 
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name) {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
     * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     * 
     * @param name
     * @return boolean
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * 
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * 
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     * 
     * @param name
     * @return
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * 
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return beanFactory.getAliases(name);
    }

}

  最后，在具体业务逻辑中，调用插入请求的方法，即可。

TradeGetFundInfoQueue.put(userId, tradeId, quota, repaymentType, timeLimit);

四、测试函数

由于在项目中，所以我写了另外一个测试函数（这个测试函数，会在下一篇文章中再次遇到），放在这里。供大家参考：

public class TestThreadPool {

    public static BlockingQueue<Runnable> queue = new  ArrayBlockingQueue<Runnable>(
            10000);
 
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            queue.add(new TestThread("初始化"));
        }
 
        final ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 15, TimeUnit.SECONDS, queue);

        executor.prestartCoreThread();

 
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("getActiveCount=" + executor.getActiveCount()
                                    + ";getKeepAliveTime=" + executor.getKeepAliveTime(TimeUnit.SECONDS)
                                    + ";getCompletedTaskCount=" + executor.getCompletedTaskCount()
                                    + ";getCorePoolSize=" + executor.getCorePoolSize()
                                    + ";getLargestPoolSize=" + executor.getLargestPoolSize()
                                    + ";getMaximumPoolSize=" + executor.getMaximumPoolSize()
                                    + ";getPoolSize=" + executor.getPoolSize()
                                    + ";getTaskCount=" + executor.getTaskCount()
                                    + ";getQueue().size()=" + executor.getQueue().size()
                    );
                    try {
                        Thread.currentThread().sleep(200L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (true) {
                    queue.add(new TestThread("生产者"));
                    try {
                        Thread.currentThread().sleep(100L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    i++;
                    if (i > 100) break;
                }
            }
        }).start();
    }
}
 
class TestThread implements Runnable {
    public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private String name;        //创建者
    private Date addDate;       //添加到队列的日期
 
    TestThread(String name) {
        this.name = name;
        this.addDate = new Date();
    }
 
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +
                "：创建者=" + name + "，创建时间=" + sdf.format(addDate) + "，执行时间=" + sdf.format(new Date()) + ",当前队列大小=" + TestThreadPool.queue.size());
 
        System.out.println(TestThreadPool.queue.peek());
        try {
            Thread.currentThread().sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试的结果大致是这个样子的：

最后，希望这篇文章对你有帮助，感谢朋友的帮助！