java 线程池之 newScheduledThreadPool

线程的实现方式
线程池的使用

newScheduledThreadPool 和其他线程池最大的区别是使用的阻塞队列是 DelayedWorkQueue，而且多了两个定时执行的方法scheduleAtFixedRate和scheduleWithFixedDelay

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

示例代码：

public class ScheduledThreadPoolTest {
    // 线程数
    private static final int threads = 10;
    // 用于计数线程是否执行完成
    CountDownLatch countDownLatch = new CountDownLatch(threads);

    /**
     * newScheduledThreadPool execute
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test1() throws InterruptedException {
        System.out.println("---- start ----");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(threads);
        for (int i = 0; i < threads; i++) {
            scheduledThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        System.out.println(e);
                    } finally {
                        countDownLatch.countDown();
                    }
                }
            });
        }
//        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newScheduledThreadPool submit submit
     */
    @Test
    public void test2() throws InterruptedException {
        System.out.println("---- start ----");
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(threads);
        for (int i = 0; i < threads; i++) {
//            Callable 带返回值
            scheduledThreadPool.submit(new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        countDownLatch.countDown();
                    }
                }
            }));
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newScheduledThreadPool submit Callable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test3() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(threads);
        for (int i = 0; i < threads; i++) {
//          Runnable 带返回值
            FutureTask<?> futureTask = new FutureTask<>(new Callable<String>() {
                /**
                 * call
                 * @return currentThreadName
                 */
                @Override
                public String call() {
                    return Thread.currentThread().getName();
                }
            });
            scheduledThreadPool.submit(new Thread(futureTask));
            System.out.println(futureTask.get());
        }
        System.out.println("---- end ----");
    }

    /**
     * newScheduledThreadPool scheduleAtFixedRate Callable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test4() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(threads);
        for (int i = 0; i < threads; i++) {
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
//                        countDownLatch.countDown();
                    }
                }
            }, 0, 3, TimeUnit.SECONDS);
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }

    /**
     * newScheduledThreadPool submit Callable
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    @Test
    public void test5() throws ExecutionException, InterruptedException {
        System.out.println("---- start ----");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(threads);
        for (int i = 0; i < threads; i++) {
            scheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
//                        countDownLatch.countDown();
                    }
                }
            }, 0, 3, TimeUnit.SECONDS);
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }
}

java 线程池之 newScheduledThreadPool

猜你喜欢