Java线程池框架

Executor（Java1.5）线程池的优点

重用存在的线程，减少对象创建、消亡的开销，可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免独色提供定时执行、定期执行、单线程、并发数控制等功能。

Executors工厂类

Executors提供四种线程池：

• public static ExecutorService newFixedThreadPool(int nThreads) 创建固定数目线程的线程池。以共享的无界队列方式来运行这些线程。
• public static ExecutorService newCachedThreadPool() 创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建有个新线程并添加到池中。终止并从缓存中移除那些已有60秒中未被使用的线程。缓存型池子通常用于执行一些生存期很短的异步型任务。
• public static ExecutorService newSingleThreadExecutor()创建一个单线程的ExecutorService。
• public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

ExecutorService

ExecutorService是一个接口，ExecutorService接口继承了Executor接口，定义了一些生命周期的方法。

public interface ExecutorService extends Executor{

void shutdown();//顺次关闭ExecutorService，停止接收新的任务，等待所有已提交的任务执行完毕之后关闭ExecutorService

List<Runnable> shutdownNow();//阻止等待任务启动并试图停止当前正在执行的任务，停止接收新的任务，返回处于等待的任务列表

boolean isShutdown();//判断线程池是否已经关闭

boolean isTerminated();//如果关闭后所有任务都已完成，则返回true。除非首先调用shutdown()或shutdownNow(),否则isTerminated永不为true。

}

Executor执行Runnable任务一旦Runnable任务传递到execute()方法，该方法便会自动在一个线程上执行。Runnable任务没有返回值。

Executor执行Callable任务有返回值，并且Callable的call()方法只能通过ExecutorService的submit(Callable task)方法来执行，并且返回一个Future，是表示任务等待完成的future。如果Future的返回尚未完成，则get()方法会阻塞等待，直到Future完成返回，可用isDone()方法判断FUture是否完成了返回。

自定义线程池

可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池，用该类很容易实现自定义的线程池。

package com.jc.custom.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {

	public static void main(String[] args){   
		
		//创建等待队列
		BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
		
		//创建线程池，池中保存的线程数是3，允许的最大线程数是5
		ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,60,TimeUnit.MILLISECONDS,bqueue);
		
		
		 //创建七个任务   
        Runnable t1 = new MyThread();   
        Runnable t2 = new MyThread();   
        Runnable t3 = new MyThread();   
        Runnable t4 = new MyThread();   
        Runnable t5 = new MyThread();   
        Runnable t6 = new MyThread();   
        Runnable t7 = new MyThread();   
        //每个任务会在一个线程上执行  
        pool.execute(t1);   
        pool.execute(t2);   
        pool.execute(t3);   
        pool.execute(t4);   
        pool.execute(t5);   
        pool.execute(t6);   
        pool.execute(t7);   
        //关闭线程池   
        pool.shutdown();   
		
	}
}
class MyThread implements Runnable{   
    @Override   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");   
        try{   
            Thread.sleep(100);   
        }catch(InterruptedException e){   
            e.printStackTrace();   
        }   
    }   
}