6.5.4 java预定义线程池ScheduledThreadPoolExecutor 理解、使用示例

最新推荐文章于 2022-04-30 20:52:08 发布

黑皮爱学习

最新推荐文章于 2022-04-30 20:52:08 发布

阅读量459

点赞数

分类专栏： java并发编程文章标签：多线程 java thread 并发编程

本文链接：https://blog.csdn.net/qq_22701869/article/details/107215919

版权

java并发编程专栏收录该内容

57 篇文章 4 订阅

订阅专栏

使用demo1：newSingleThreadScheduledExecutor的顺序执行

schedule：延时3秒执行

scheduleAtFixedRate：固定时间间隔执行任务

scheduleWithFixedDelay：然后执行完任务后，延迟3秒再周期执行当前任务

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

两个构造方法

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService executorService1 = Executors.newScheduledThreadPool (1);
        ScheduledExecutorService executorService2 = Executors.newScheduledThreadPool( 1,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;
            }
        });
    }
}

有两种类型

ScheduledThreadPoolExecutor：包含多个线程的

SingleThreadScheduledExecutor：只包含一个线程的

构造理解

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

corePoolSize=0；maximumPoolSize=Integer.MAX_VALUE，最大会创建Integer.MAX_VALUE线程执行任务
等待时间默认是60秒，意味着空闲线程等待60无任务就会终止
使用CachedThreadPool无界阻塞队列，会不断创建线程

适用场景

ScheduledThreadPoolExecutor：包含多个线程的执行的周期任务，同时要限制后台线程的数量

SingleThreadScheduledExecutor：只包含一个线程的，要保证线程顺序地执行任务：上一个任务执行完了，才执行下一个任务

周期线程池执行的常用方法

public ScheduledFuture<?> schedule(

Runnable command,

long delay,

TimeUnit unit)

执行一次，延迟delay时间单位

public <V> ScheduledFuture<V> schedule(

Callable<V> callable,

long delay,

TimeUnit unit);

执行一次有返回值的任务，

延迟delay时间单位

public ScheduledFuture<?> scheduleAtFixedRate(

Runnable command,

long initialDelay,

long period,

TimeUnit unit)

固定时间间隔执行，首次在initialDelay时间单位后执行

然后每隔period时间单位执行一次

任务执行的时间不能超过时间间隔period（不会报错）

public ScheduledFuture<?> scheduleWithFixedDelay(

Runnable command,

long initialDelay,

long delay,

TimeUnit unit);

固定延时间隔执行，首次在initialDelay时间单位后执行

然后每隔period时间单位执行一次

每次任务完成之后都延时一个固定时间，即完成一个任务，等待delay秒

使用demo1：newSingleThreadScheduledExecutor的顺序执行

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() + "--执行完成");
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService executorService1 = Executors.newScheduledThreadPool (2);
        ScheduledExecutorService executorService2 = Executors.newScheduledThreadPool( 2,new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newScheduledThreadPool，你来打我呀");
                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("我是newSingleThreadScheduledExecutor，你来打我呀");
                return thread;
            }
        });

        //执行普通没有返回值的任务,这两个任务会按照顺序执行
        System.out.println("newSingleThreadScheduledExecutor执行普通没有返回值的任务," +
                "这两个任务会按照顺序执行,前一个任务完成，后一个任务才能开始");
        for (int i = 0; i < 3; i++) {
            executorService3.execute(new Customer());
        }

//        executorService1.execute(new Customer());
//        //执行有返回值的任务
//        Future submit = executorService1.submit(new Home(1, 10));
//        System.out.println("get()方法会阻塞，直到拿到结果"+submit.get());
    }
}

结果：上一个线程执行完成之后，下一个线程才能继续执行

newSingleThreadScheduledExecutor执行普通没有返回值的任务,这两个任务会按照顺序执行,前一个任务完成，后一个任务才能开始
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成

schedule：延时3秒执行

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 {
        ScheduledExecutorService executorService1 = Executors.newScheduledThreadPool (2);
        ScheduledExecutorService executorService2 = Executors.newScheduledThreadPool( 2,new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newScheduledThreadPool，你来打我呀");
                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("我是newSingleThreadScheduledExecutor，你来打我呀");
                return thread;
            }
        });

            System.out.println("延时3秒之后再运行");
            executorService3.schedule(new Customer(),3,TimeUnit.SECONDS);
            System.out.println("延时3秒之后再运行有返回任务");
        ScheduledFuture schedule = executorService3.schedule(new Home(1, 10), 3, TimeUnit.SECONDS);

        System.out.println("get()方法会阻塞，直到拿到结果"+schedule.get());
    }
}

结果：

延时3秒之后再运行
延时3秒之后再运行有返回任务
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
get()方法会阻塞，直到拿到结果55

scheduleAtFixedRate：固定时间间隔执行任务

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

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService executorService1 = Executors.newScheduledThreadPool (2);
        ScheduledExecutorService executorService2 = Executors.newScheduledThreadPool( 2,new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newScheduledThreadPool，你来打我呀");
                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("我是newSingleThreadScheduledExecutor，你来打我呀");
                return thread;
            }
        });

        System.out.println("1秒之后首次运行，然后每隔3秒运行一次");
        executorService3.scheduleAtFixedRate(new Customer(),1,3,TimeUnit.SECONDS);
    }
}

结果：

1秒之后首次运行，然后每隔3秒运行一次
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
。。。。。。

scheduleWithFixedDelay：然后执行完任务后，延迟3秒再周期执行当前任务

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() + "--执行完成");
        }
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService executorService1 = Executors.newScheduledThreadPool(2);
        ScheduledExecutorService executorService2 = Executors.newScheduledThreadPool(2, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("我是newScheduledThreadPool，你来打我呀");
                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("我是newSingleThreadScheduledExecutor，你来打我呀");
                return thread;
            }
        });
        System.out.println("1秒之后首次运行，然后执行完任务后，延迟3秒再周期执行当前任务");
        executorService3.scheduleWithFixedDelay(new Customer(), 1, 3, TimeUnit.SECONDS);
    }
}

结果

1秒之后首次运行，然后执行完任务后，延迟3秒再周期执行当前任务
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
pool-2-thread-1--开始执行
pool-2-thread-1--执行完成
。。。。。。

黑皮爱学习

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
6.5.4 java预定义线程池ScheduledThreadPoolExecutor 理解、使用示例

目录两个构造方法有两种类型构造理解适用场景周期线程池执行的常用方法使用demo1：newSingleThreadScheduledExecutor的顺序执行schedule：延时3秒执行scheduleAtFixedRate：固定时间间隔执行任务scheduleWithFixedDelay：然后执行完任务后，延迟3秒再周期执行当前任务如果不了解线程池的各个参数的含义，可以查看此文章线程池的优点、以及各个参数的意义、使用示例两个构造方法一个多了一个线程工厂的..
复制链接

扫一扫