Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，\

可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，

超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，

保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1).newCachedThreadPool

ExcutorService cachedThreadPool = Executors.newCacheThreadPool();

for(int i = 0 ; i<10; i++) {

final int index = i;

try {

Thread.sleep(index.1000);

} catch (InterruptedException e ) {

e.printStackTrace();

}

}

cachedThreadPool.execute(new Runable() {

@Override

public void run() {

System.out.println(index);

});

}

(2).创建定长 线程池

ExecutorService exePool = Executors.newFixedThreadPool(20);

exePool.execute( new validateDataTheadNew(

begin,begin+200,changeValue,allDatas,rightDatas,errorDatas,paramaters));

private class validateDataTheadNew implements Runnable {

//变量 参数

//变量 参数

public validateDataTheadNew(Integer begin,Integer end ,IntValue changeValue,List<ImportStNoView> importDatas,List<ImportStNoView> rightDatas,List<ImportStNoView> errorDatas,String[] paramaters){

this.begin = begin;

this.end = end;

this.changeValue = changeValue;

this.importDatas = importDatas;

this.rightDatas = rightDatas;

this.errorDatas = errorDatas;

this.paramaters = paramaters;

} //这段构造方法

public void run () {

try{

SessionFactory sessionFactory = shopterNoApplyDao.getHibernateTemplate().getSessionFactory();

Session session = sessionFactory.openSession();

TransactionSynchronizationManager.bindResource(sessionFactory,

new SessionHolder(session));

for(int i = begin;i<end;i++){

ImportStNoView report = importDatas.get(i);

String errorInfo = validateExpressData(report,paramaters);

if(StringUtils.isNotEmpty(errorInfo)){

report.setErrorInfo(errorInfo);

errorDatas.add(report);

}else{

rightDatas.add(report);

}

}

changeValue.setIntValue(1);

TransactionSynchronizationManager.unbindResource(sessionFactory);

SessionFactoryUtils.closeSession(session);

}catch(Exception e ){

e.printStackTrace();

changeValue.setIntValue(2);

}

}

}

}

//TransactionSynchronizationManager.bindResource( sessionFactory,new SessionHolder(session));

在调用一个需要事务的组件的时候，管理器首先判断当前调用

(即当前线程)有没有一个事务，如果没有事务则启动一个事务,并把事务与当前线程绑定

Spring 使用TransactionSynchronizationManager的 bindResource方法、

将当前线程与一个事务绑定

(3). ScheduleExecutorService scheduledThreadPool

= Executors.newScheduledThreadPool(5);

scheduledThreadPool.schedule ( new Runable() {

@Override

public void run () {

system.out.println("delay 3 seconds");

}

},3,TimeUnit.seconds);

//表示 延迟 3秒 执行

//

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println("delay 1 seconds, and excute every 3 seconds");

}

}, 1, 3, TimeUnit.SECONDS);

//延迟一秒后 每三秒执行一次

(4) ExecutorService single

= Executors.newSingleThreadExecutor();

for(int i = 0 ;i<10;i++ ) {

final int index = i;

singleThreadExecutor.execute(new Runable() {

@Override

public void run () {

system.out.println(index);

Thread.sleep(2000);

}

)

}

线程池的作用 ：

就是限制系统中执行线程的数量'

任务执行 等待 队列

ExecutorService 真正的线程池接口。

ScheduledExecutorService 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。

ThreadPoolExecutor ExecutorService的默认实现。

ScheduledThreadPoolExecutor

继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。