Executor的介绍及线程池的应用

public interface ExecutorService extends Executor {}
public abstract class AbstractExecutorService implements ExecutorService {}
public interface ScheduledExecutorService extends ExecutorService {}
public class ThreadPoolExecutor extends AbstractExecutorService {}
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {}

区别：

　　1.ExecutorService 接口继承了Executor 接口，是Executor 的子接口。


　　2.Executor接口中定义了execute()方法，用来接收一个Runnable接口的对象，

　　  　　 而ExecutorService接口中定义的submit()方法可以接收Runnable和Callable接口对象。


　　3.Executor接口中execute()方法不返回任何结果，而ExecutorService接口中submit()方法可以通过一个 Future 对象返回运算结果。


　　4.Executor和ExecutorService除了允许客户端提交一个任务，ExecutorService 还提供用来控制线程池的方法。

　　   　　比如：调用 shutDown() 方法终止线程池。

　　5.Executors 类提供工厂方法用来创建不同类型的线程池。比如: 

 　　 　newSingleThreadExecutor() 创建一个只有一个线程的线程池，

   　　newFixedThreadPool(int numOfThreads)来创建固定线程数的线程池，

   　　newCachedThreadPool()创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

 　　　　newScheduledThreadPool(int corePoolSize) 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

    public static void main(String[] args) {
        // 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
        Executor cachedThreadPool = Executors.newCachedThreadPool();
        // 循环10次
        for (int i = 0; i < 10; i++) {
            // 初始化index作为线程内输出，要求final
            final int index = i;
            // 等待，让前一个线程执行完成
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 执行任务
            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    // 输出线程名称
                    System.out.println(index+" 线程名称："+Thread.currentThread().getName());
                }
            });
        }
    }

    public static void main(String[] args) {
        // 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        fixedThreadPool.shutdown();
    }

    public static void main(String[] args) {
        // 创建一个定长线程池，支持定时及周期性任务执行。
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            scheduledThreadPool.schedule(new Runnable() {
                public void run() {
                    System.out.println("delay 3 seconds "+Thread.currentThread().getName());
                }
            }, 3, TimeUnit.SECONDS);// 3s以后执行
        }
        scheduledThreadPool.shutdown();
    }

public static void main(String[] args) {
        /**
         * 单线程化的线程池
         */
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    Thread.currentThread().setName("Thread i = " + index);
                    System.out.println(Thread.currentThread().getName() + " index = " + index);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        System.out.println("ssss");
                    }
                }
            });
        }
        singleThreadExecutor.shutdown();
        System.out.println("on the main thread...");

    }