6.5.2 java预定义线程池SingleThreadExecutor 理解、使用示例

如果不了解线程池的各个参数的含义，可以查看此文章线程池的优点、以及各个参数的意义、使用示例

四个构造方法

 一个多了一个线程工厂的参数，能够对参数名等进行设置；

返回带延迟、循环执行的单例线程池

其中的定式线程池可参考：https://blog.csdn.net/qq_22701869/article/details/107215919

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
        ExecutorService executorService3 = Executors.newSingleThreadScheduledExecutor();
        ExecutorService executorService4 = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newFixedThreadPool，你来打我呀");
                return thread;
            }
        });
        ExecutorService executorService2 = Executors.newSingleThreadExecutor( new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newFixedThreadPool，你来打我呀");
                return thread;
            }
        });

    }
}

构造理解

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

1. SingleThreadExecutor 用于只创建1一个线程的线程池，他的corePoolSize=maximumPoolSize=1
2. 当线程数>corePoolSize,等待时间默认是0，意味着多余的线程会立马跑出异常终止
3. 使用LinkedBlockingQueue有界阻塞队列，默认容量是Integer.MAX_VALUE

适用场景

在任意时间点，只有一个任务是活动的：能够保准任务是顺序执行的

使用demo

public class Test {
    static class Customer extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "--开始执行");
            try {
                //模拟任务执行4s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "--执行完成");
        }
    }
    static class Home implements Callable {
        int start;
        int end;

        public Home(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = start; i <=end; i++) {
                sum+=i;
            }
            return sum;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();
        ExecutorService executorService2 = Executors.newSingleThreadExecutor( new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newFixedThreadPool，你来打我呀");
                return thread;
            }
        });
        //拥有延时功能的单例线程池
        ScheduledExecutorService executorService3 = Executors.newSingleThreadScheduledExecutor();
        ScheduledExecutorService executorService4 = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newFixedThreadPool，你来打我呀");
                return thread;
            }
        });

        //执行普通没有返回值的任务,这两个任务会按照顺序执行
        executorService1.execute(new Customer());
        executorService1.execute(new Customer());
        //执行有返回值的任务
        Future submit = executorService1.submit(new Home(1, 10));
        System.out.println("get()方法会阻塞，直到拿到结果"+submit.get());

        //延迟任务1秒之后执行，以后每隔1秒执行一次
        System.out.println("延迟任务1秒之后执行");
        executorService3.scheduleAtFixedRate(new Customer(),1,1,TimeUnit.SECONDS);
        //执行有返回值的任务
        //Future submit2 = executorService2.submit(new Home(1,10));
        //System.out.println("get()方法会阻塞，直到拿到结果"+submit2.get());

    }
}

结果：保证线程是顺序执行的

pool-1-thread-1--开始执行
pool-1-thread-1--执行完成
pool-1-thread-1--开始执行
pool-1-thread-1--执行完成
get()方法会阻塞，直到拿到结果55
延迟任务1秒之后执行、以后每隔1秒执行一次
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
。。。。。。