线程池

最近业务需求，需要导出大量数据到Excel文档中。
1>Action文件
//ExecutorService pool = Executors.newSingleThreadExecutor();
// 记录日志  异步将导出的xls文件写到服务器的制定目录
ExpProductThread thread = new ExpProductThread(new Long(0),this.getCommandContext().getUserId(),workbook,exportFileName);
//thread.start();
XiuECThreadPoolRegistry.getInstance().getThreadPool().execute(thread);
//pool.execute(thread);
//pool.shutdown();
/*****add by sam.shi 2011-09-23*****/

2>线程：
package com.xiu.commerce.product.helpers;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import com.ibm.commerce.ras.ECTrace;
import com.ibm.commerce.ras.ECTraceIdentifiers;
import com.xiu.commerce.helpers.XiuECApplicationConfigRegistry;
import com.xiu.commerce.log.beans.LogBean;
import com.xiu.commerce.log.beans.LogManager;
import com.xiu.commerce.log.helpers.ECLogMessage;
public class ExpProductThread extends Thread
{
    /**
     * 操作名称
     */
    private String       atcion;

    /**
     * 操作日志
     */
    private String       stanceLog;

    /**
     * 操作日志内容
     */
    private String       note;

    /**
     * 用户ID
     */
    private Long         userId;

    /**
     * 业务ID
     */
    private Long         instanceId;

    /**
     * EXCEL操作对象
     */
    private HSSFWorkbook workbook;

    /**
     * EXCEL文件名称
     */
    private String       fileName;

    public ExpProductThread(Long instanceId, Long userId, HSSFWorkbook workbook, String fileName)
    {
        this.atcion = "导出EXCEL";
        this.stanceLog = "导出商品信息";
        this.note = "导出商品信息,导出的EXCEL文件路径为：";
        this.userId = userId;
        this.instanceId = instanceId;
        this.workbook = workbook;
        this.fileName = fileName;
    }

    public void run()
    {
        ECTrace.entry(ECTraceIdentifiers.COMPONENT_EXTERN, ExpProductThread.class.getName(), "run");
        StringBuffer sb = new StringBuffer(100);
        SimpleDateFormat df = new SimpleDateFormat(XiuECApplicationConfigRegistry.getInstance().getValue("ExpFile/formatStr"));
        String time = df.format(new java.util.Date());
        sb.append(XiuECApplicationConfigRegistry.getInstance().getValue("ExpFile/path"));
        sb.append(time);
        sb.append(File.separator);

        OutputStream out = null;
        try
        {
            File file = new File(sb.toString());
            if (!file.exists())
                file.mkdirs();
            out = new FileOutputStream(new File(sb.append(fileName).toString()));
            this.workbook.write(out);

            // 记录操作日志
            this.insertLog(atcion, stanceLog, note + sb.toString(), userId, instanceId);
        }
        catch (Exception e)
        {
            //e.printStackTrace();
            ECTrace.trace(ECTraceIdentifiers.COMPONENT_EXTERN, ExpProductThread.class.getName(), "run", "出现异常："
                    + e.toString());
        }
        finally
        {
            try
            {
                if (null != out)
                    out.close();
            }
            catch (IOException e)
            {
                // TODO 自动生成 catch 块
                //e.printStackTrace();
            }

            ECTrace.exit(ECTraceIdentifiers.COMPONENT_EXTERN, ExpProductThread.class.getName(), "run");
        }
    }

    /**
     * 写操作日志
     * @param atcion 操作名称
     * @param stanceLog 操作日志
     * @param note 操作日志内容
     * @param userId 用户ID
     */
    private void insertLog(String atcion, String stanceLog, String note, Long userId, Long instanceId)
    {
        LogManager logManager = new LogManager();
        LogBean logBean = new LogBean();
        logBean.setEvenLevel(ECLogMessage.EVEN_LEVEL_INFO);// 级别等级：1:info,2:debug,3:error,(属性文件)
        logBean.setEvenSystem(ECLogMessage.EVEN_SYSTEM_STORE);// 在属性文件中配置，例如：1-商品中心
        logBean.setEvenModule(ECLogMessage.EVEN_MODULE_STORE);// 在属性文件里配置，例如：1：品牌管理，2：分类管理，3：商品信息，4：属性字典，5：价格管理，6：库存管理，7：上下架管理，8：档期列表
        logBean.setEvenAction(atcion);// 导出
        logBean.setEvenInstance(stanceLog); //导出
        logBean.setEvenNote(note);// 导出
        logBean.setEvenInstanceId(instanceId.toString());
        logBean.setEvenUserID(userId.intValue());//用户Id
        logManager.setLogData(logBean);
    }
}
3》线程池 在系统启动时会自动初始化线程池
public class XiuECThreadPoolRegistry implements Registry
{
    private static int                     poolSize = 3;

    private static ExecutorService         pool     = null;

    private static XiuECThreadPoolRegistry instance = null;

    public static XiuECThreadPoolRegistry getInstance()
    {
        if (instance == null)
        {
            instance = (XiuECThreadPoolRegistry) RegistryManager.singleton().getRegistry("XiuECThreadPoolRegistry");
        }
        return instance;
    }

    public ExecutorService getThreadPool()
    {
        if (null == pool)
        {
            String poolsize = XiuECApplicationConfigRegistry.getInstance().getValue("ThreadPool/size");
            if (!StringUtil.isEmpty(poolsize))
                pool = Executors.newFixedThreadPool(Integer.parseInt(poolsize));
            else
                pool = Executors.newFixedThreadPool(poolSize);
        }
        return pool;
    }

    @Override
    public void initialize() throws Exception
    {
        this.refresh();
    }

    @Override
    public void refresh() throws Exception
    {
        String methodName = "initialize";
        ECTrace.entry(ECTraceIdentifiers.COMPONENT_EXTERN, this.getClass().getName(), methodName);
        if (null == pool)
        {
            String poolsize = XiuECApplicationConfigRegistry.getInstance().getValue("ThreadPool/size");
            ECTrace.trace(ECTraceIdentifiers.COMPONENT_EXTERN, this.getClass().getName(), methodName, "线程池大小："
                    + poolsize);
            if (!StringUtil.isEmpty(poolsize))
                pool = Executors.newFixedThreadPool(Integer.parseInt(poolsize));
            else
                pool = Executors.newFixedThreadPool(poolSize);
        }
        ECTrace.exit(ECTraceIdentifiers.COMPONENT_EXTERN, this.getClass().getName(), methodName);
    }
}
转：
在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后，通过Executor来启动线程比用Thread的start（）更好。在新特征中，可以很容易控制线程的启动、执行和关闭过程，还可以很容易使用线程池的特性。

　　一、创建任务

　　任务就是一个实现了Runnable接口的类。

　　创建的时候实run方法即可。

　　二、执行任务

　　通过java.util.concurrent.ExecutorService接口对象来执行任务，该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。

　　Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

　　ExecutorService提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService，这将导致其停止接受新任务。关闭后，执行程序将最后终止，这时没有任务在执行，也没有任务在等待执行，并且无法提交新任务。

　　executorService.execute（new TestRunnable（））；

　　1、创建ExecutorService

　　通过工具类java.util.concurrent.Executors的静态方法来创建。

　　Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

　　比如，创建一个ExecutorService的实例，ExecutorService实际上是一个线程池的管理工具：

　　ExecutorService executorService = Executors.newCachedThreadPool（）；

　　ExecutorService executorService = Executors.newFixedThreadPool（3）；

　　ExecutorService executorService = Executors.newSingleThreadExecutor（）；

　　2、将任务添加到线程去执行

　　当将一个任务添加到线程池中的时候，线程池会为每个任务创建一个线程，该线程会在之后的某个时刻自动执行。

　　三、关闭执行服务对象

　　executorService.shutdown（）；

　　四、综合实例

package concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* Created by IntelliJ IDEA.
*
* @author leizhimin 2008-11-25 14:28:59
*/
public class TestCachedThreadPool {
        public static void main(String[] args) {
//                ExecutorService executorService = Executors.newCachedThreadPool();
                ExecutorService executorService = Executors.newFixedThreadPool(5); //         ExecutorService executorService = Executors.newSingleThreadExecutor();

                for (int i = 0; i < 5; i++) {
                        executorService.execute(new TestRunnable());
                        System.out.println("************* a" + i + " *************");
                }
                executorService.shutdown();
        }
}

class TestRunnable implements Runnable {
        public void run() {
                System.out.println(Thread.currentThread().getName() + "线程被调用了。");
                while (true) {
                        try {
                                Thread.sleep(5000);
                                System.out.println(Thread.currentThread().getName());
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
}
Executors.newCachedThreadPool（）； //带缓存的 不够时自动添加Executors.newSingleThreadExecutor（）； //单个线程池 线程死掉后自动创建Executors.newFixedThreadPool（10）； //创建容纳N个线程的Executors.newScheduledThreadPool（19）； //创建定时器线程池

************* a0 *************
************* a1 *************
pool-1-thread-2线程被调用了。
************* a2 *************
pool-1-thread-3线程被调用了。
pool-1-thread-1线程被调用了。
************* a3 *************
************* a4 *************
pool-1-thread-4线程被调用了。
pool-1-thread-5线程被调用了。
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-5
pool-1-thread-4
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-5
pool-1-thread-4