线程池(二)-java内置线程池 ExecutorService

一、ExecutorService 接口中的方法

• void shutdown()：启动一次顺序关闭，继续执行已提交的任务(已经提交的任务会继续执行)，但不接受新任务

• List<Runnable> shutdownNow()：//停止所有正在执行的任务，暂停处理正在等待的任务，不接受新任务,并返回等待执行的任务列表

• boolean isShutdown()

• <T> Future<T> submit(Callable<T> task)：执行带返回值的任务，返回一个Future对象

• Future<?> submit(Runnable task): 执行Runable 任务，返回一个表示该任务的Future

• <T> Future<T> submit(Runnable task, T result): 执行Runable 任务，返回一个表示该任务的Future

二、获取 ExecutorService

• static ExecutorService newCachedThreadPool()：创建一个默认的线程池对象 ，里面的线程可重用，且在第一次使用时才创建
• static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)：线程池中的所有线程都使用ThreadFactory来创建；这样的线程无需手动启动，自动执行
• static ExecutorService newFixedThreadPool(int nThreads)：创建一个可重用固定线程数的线程池
• static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)：创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建
• static ExecutorService newSingleThreadExecutor()：创建一个使用单个线程的Executor，以无界队列方式来运行该线程(即不限制线程数量)
• static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)：创建一个使用单个线程的Executor，且线程池中的所有线程都使用ThreadFactory来创建

三、使用案例

创建任务类

public class MyThread implements Runnable{
	//线程ID
    private int id;

    public MyThread(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        System.out.println("执行了："+Thread.currentThread().getName()+",编号："+id);
        try {
            Thread.sleep(20000);
            System.out.println("睡眠结束。。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1、通过 newCachedThreadPool 获取 ExecutorService

public class UseNewCacheThreadPool {
    public static void main(String[] args) {
        test1();
        //test2();
    }

    public static void test1(){
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
//		启动一次顺序关闭，执行以前提交的任务，但不接受新任务
//		es.shutdown();
//		停止所有正在执行的任务，暂停处理正在等待的任务，不接受新任务,并返回等待执行的任务列表
//      es.shutdownNow();
//      es.submit(new MyThread(123));//报异常，shutdown/shutdownNow后不能提交线程
    }

	/**
     * 自定义线程
     */
    public static void test2(){
        ExecutorService es = Executors.newCachedThreadPool(new ThreadFactory() {
            int i;
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r,"自定义线程"+(i++));
            }
        });
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
}

2、通过 newFixedThreadPool 获取 ExecutorService

public class UseNewFixedThreadPool {
    public static void main(String[] args) {
        test2();
    }

    public static void test1(){
        ExecutorService es = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
	/**
     * 自定义线程
     */
    public static void test2(){
        ExecutorService es = Executors.newFixedThreadPool(3, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        });
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
}

3、通过 newSingleThreadExecutor 获取 ExecutorService

public class UseNewSingleThreadExecutor {
    public static void main(String[] args) {
        test1();
    }

    public static void test1(){
        ExecutorService es = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }

    public static void test2(){
        ExecutorService es = Executors.newSingleThreadExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        });
        for (int i = 0; i < 10; i++) {
            es.submit(new MyThread(i));
        }
    }
}