Java 線程池創建的四種方式

閑話少敘... 

package com.adao.thread;

import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPool {
    /**
     * 1.創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程
     */
    public static void cachedThreadPool() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int j = 0; j < 10; j++) {
            for (int i = 0; i < 10; i++) {
                final int index = i;
//                 try {
//                     Thread.sleep(1000);
//                 } catch (InterruptedException e) {
//                     e.printStackTrace();
//                 }
                cachedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(index + "--" + Thread.currentThread().getId() + " name:"
                                + Thread.currentThread().getName());
                    }
                });
            }
        }

    }

    /**
     * 2.創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待
     */
    public static void newFixedThreadPool() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        for (int j = 0; j < 10; j++) {
            for (int i = 0; i < 10; i++) {
                final int index = i;
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println(index + "----" + Thread.currentThread().getId() + " name:"
                                    + Thread.currentThread().getName());

                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
        // 兩種關閉方式
//         fixedThreadPool.shutdown(); //不會立即終止線程池，而是要等所有任務緩存隊列中的任務都執行完后才終止，但再也不會接受新的任務
//        fixedThreadPool.shutdownNow(); //立即終止線程池，並嘗試打斷正在執行的任務，並且清空任務緩存隊列，返回尚未執行的任務
    }

    /**
     * 3.創建一個定長線程池，支持定時及周期性任務執行
     */
    public static void newScheduledThreadPool() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(50);
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, 10); // 時
        calendar.set(Calendar.MINUTE, 53);// 分
        calendar.set(Calendar.SECOND, 00); // 秒
        // 計算現在時間和計划任務執行時間差多久，單位毫秒
        Long date = calendar.getTime().getTime() - System.currentTimeMillis();
//        //延遲3秒執行
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("delay 3 seconds--" + new Date().toLocaleString() + " name:"
                        + Thread.currentThread().getName());
            }
        }, 3, TimeUnit.SECONDS);

        // 延遲5秒執行，然后每隔2秒執行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延遲5秒執行，然后每隔2秒執行一次--" + new Date().toLocaleString() + " name:"
                        + Thread.currentThread().getName());
            }
        }, 5, 2, TimeUnit.SECONDS);

        // 定時在某一時刻執行任務，然后間隔執行,如果時間過了會立馬執行
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("定時在某一時刻執行任務，然后間隔執行--" + new Date().toLocaleString() + " name:"
                        + Thread.currentThread().getName());
            }
        }, date / 1000, 2, TimeUnit.SECONDS);
    }

    /**
     * 4. 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務， 保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行
     */
    public static void newSingleThreadExecutor() {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("單線程執行任務。。。" + Thread.currentThread().getName());
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    public static void main(String[] args) {
//        cachedThreadPool();
//        newFixedThreadPool();
//        newScheduledThreadPool();
        newSingleThreadExecutor();
    }
}

執行結果：

newSingleThreadExecutor();

 

 

newFixedThreadPool();

 

 

細心的人可以觀察到：

Thread.currentThread().getId()  和 Thread.currentThread().getName()的關系。

perfect