线程池的实现

1.newSingleThreadExecutor()

创建一个单线程池。这个线程池中只有一个线程执行。如果一个线程因为异常结束，会有一个新的线程替换它。线程池保证所有的任务按照先后顺序完成执行完，最多会有一个任务处于活动状态，并且不予许使用者改动线程池实例，因此可以避免改变线程数目。

package com.sxt.thread;

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("运行线程"+Thread.currentThread().getName());
    }
}

package com.sxt.thread;

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

public class TestSingleThreadExecutor {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService pool= Executors.newSingleThreadExecutor();
        Thread s1=new MyThread();
        Thread s2=new MyThread();
        Thread s3=new MyThread();
        Thread s4=new MyThread();
        Thread s5=new MyThread();
        //将线程放入线程池中
        pool.execute(s1);
        pool.execute(s2);
        pool.execute(s3);
        pool.execute(s4);
        pool.execute(s5);
        //关闭线程池
        pool.shutdown();
    }
}

2.newFixedThreadPool

创建一个固定大小的线程池，每次提交交任务就创建一个新的线程池，直到线程达到线程池的最大，如果某个线程应为异常结束，那么线程池会补充一个新的线程

package com.sxt.thread;

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("运行线程"+Thread.currentThread().getName());
    }
}

package com.sxt.thread;

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

public class TestFixedThreadPool{
    public static void main(String[] args) {
        //创建线程池
        ExecutorService pool=Executors.newFixedThreadPool(3);
        Thread s1=new MyThread();
        Thread s2=new MyThread();
        Thread s3=new MyThread();
        Thread s4=new MyThread();
        Thread s5=new MyThread();
        //将线程放入线程池中
        pool.execute(s1);
        pool.execute(s2);
        pool.execute(s3);
        pool.execute(s4);
        pool.execute(s5);
        //关闭线程池
        pool.shutdown();
    }
}

3.newCachedThreadPool

用来处理大量短时间工作任务的线程池,线程规模可无限大,它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置时间超过60秒，则被终止并移除缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用SynchronousQueue作为工作队列。

package com.sxt.thread;

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("运行线程"+Thread.currentThread().getName());
    }
}

package com.sxt.thread;

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

public class TestCachedThreadPool{
    public static void main(String[] args) {
        //创建线程池
        ExecutorService pool=Executors.newCachedThreadPool(3);
        Thread s1=new MyThread();
        Thread s2=new MyThread();
        Thread s3=new MyThread();
        Thread s4=new MyThread();
        Thread s5=new MyThread();
        //将线程放入线程池中
        pool.execute(s1);
        pool.execute(s2);
        pool.execute(s3);
        pool.execute(s4);
        pool.execute(s5);
        //关闭线程池
        pool.shutdown();
    }
}

4.newScheduledThreadPool

创建一个无限大的线程池，它的核心线程数量是固定的，而非核心线程数是没有限制的，并且当非核心线程闲置时会被立即回收，它可安排给定延迟后运行命令或者定期地执行。这类线程池主要用于执行定时任务和具有固定周期的重复任务。

public class PoolExecutorTest {
 
	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		
		//设置池中核心数量是2
        ScheduledExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(2);  
        System.out.println("现在的时间:"+System.currentTimeMillis());
        mScheduledThreadPool.schedule(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("现在的时间:"+System.currentTimeMillis());
				
			}
		}, 4, TimeUnit.SECONDS);//这里设置延迟4秒执行
		
 
	}
 
}

5.各个类型的设计目的

1、Executor是一个基础的接口，其初衷是将任务提交和任务执行细节解耦，这一点可以天汇其定义的唯一方法。

void execute(Runnable command);

2、ExecutorService则更加完善，不仅提供service管理，比如shutdown等方法，也提供了更加全面的提交任务机制，如返回Future而不是 void 的 submit 方法

Future submit(Callable task);

3、Java标准类库提供了几种基础实现，比如 ThreadPoolExecutor、ScheduledThreadPoolExecutor、ForkJoinPool。这些线程池设的设计特点在于其高度的可调节性和灵活性，以尽量满足复杂多变的实际应用场景，我会进一步分析其构建部分的源码，剖析这种灵活性的源头。

4、Executors则从简化使用的角度，为我们提供了各种方便的静态工长方法。