java thread pool newScheduledThreadPool

• How the thread is implemented

  • java multi-threaded extends Thread

  • java multi-threaded implements Runnable

  • Java multi-threaded implements Callable

• Use of thread pool

  • Introduction to thread pools

  • ThreadPoolExecutor

    • java thread pool newScheduledThreadPool

    • java thread pool newCachedThreadPool

    • java thread pool newFixedThreadPool

    • java thread pool newSingleThreadExecutor

  • ForkJoinPool

    • java thread pool newWorkStealingPool

 

The biggest difference between newScheduledThreadPool and other thread pools is that the blocking queue used is DelayedWorkQueue, and there are two more timed execution methods scheduleAtFixedRate and scheduleWithFixedDelay

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

Sample code:

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 ----");
    }
}