快捷導(dǎo)航

java中的異步加載new Thread()方式

更新時間：2023年08月28日 16:13:50 作者：TJkaklf

這篇文章主要介紹了java中的異步加載new Thread()方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

java的異步加載new Thread()

public class LoginInterface{
? ?public String delSession(){
? ? new Thread(new Runnable() { @Override public void run() { //需要執(zhí)行的代碼 } }).start();
? ?}}

使用匿名內(nèi)部類編譯

class LoginInterface$1
? implements Runnable
{
? LoginInterface$1(LoginInterface paramLoginInterface, String paramString)
? {
? }
? public void run()
? {
//要執(zhí)行的代碼
? }
}

聊聊new Thread()的危害

危害

1）開銷大

每次new Thread() 都會創(chuàng)建新的對象，開銷較大，無法復(fù)用增加垃圾回收的負擔。

2）管理困難

每個new Thread() 都是獨立的個體，無法有效的管控，無限制創(chuàng)建相互競爭，可能導(dǎo)致oom或者核心業(yè)務(wù)線程阻塞。

3）功能單一

無法定時執(zhí)行，中斷線程等功能。

線程池

1）復(fù)用已創(chuàng)建的線程，減少對象創(chuàng)建、消亡的開銷，性能佳。

2）可控制最大并發(fā)線程數(shù)，提高系統(tǒng)資源的使用率，同時避免過多資源競爭，避免堵塞。

3）可定時執(zhí)行、中斷線程等功能。

線程池大小

1）CPU密集型(計算型)

使用較小的線程池，一般是Cpu核心數(shù)+1
因為CPU密集型任務(wù)CPU的使用率很高，若開過多的線程，只能增加線程上下文的切換次數(shù)，帶來額外的開銷

2）IO密集型(查詢訪問型)

使用較大的線程池，一般CPU核心數(shù) * 2
因為IO密集型CPU使用率不高，可以讓CPU等待IO的時候處理別的任務(wù)，充分利用cpu時間

線程池創(chuàng)建【使用ThreadPoolExecutor手動創(chuàng)建】

public class CommonThreadPool {
    /**
     * 線程池對象
     */
    public static ExecutorService pool = null;
    /**
     * 線程池核心池的大小
     */
    private static final int CORE_POOL_SIZE = 5;
    /**
     * 獲取當前系統(tǒng)的CPU 數(shù)目
     */
    private static int cpuNums = Runtime.getRuntime().availableProcessors();
    /**
     * 線程池的最大線程數(shù)
     */
    private static final int MAX_POOL_SIZE = (cpuNums * 2) > CORE_POOL_SIZE ? (cpuNums * 2) : CORE_POOL_SIZE;
    static {
        pool = new ThreadPoolExecutor(
                CORE_POOL_SIZE,             // 核心線程數(shù)
                MAX_POOL_SIZE,              // 最大線程數(shù) 通常核心線程數(shù)=最大線程數(shù) 當MAX_POOL_SIZE > CORE_POOL_SIZE 時，并不是當核心線程全部被占用后立馬開始創(chuàng)建新的線程（只有在隊列也滿了之后才會開始新建線程）
                0L,            // 存活時間   >=0 0 永不回收【非核心線程除外】
                TimeUnit.MILLISECONDS,      // 單位
                new ArrayBlockingQueue<Runnable>(100),                          // 隊列 存放待執(zhí)行任務(wù)
                new ThreadFactoryBuilder().setNameFormat("CommonThread-%d").build(),    // 創(chuàng)建工廠
                new ThreadPoolExecutor.AbortPolicy());                                  // 拒絕策略 默認拒絕 丟棄 丟棄最老的 主線程執(zhí)行
    }
}

禁用Executors創(chuàng)建線程池

1）Executors屏蔽的線程池的內(nèi)部實現(xiàn)細節(jié)，開發(fā)人員需要根據(jù)服務(wù)器情況與業(yè)務(wù)場景定義更合適的線程池。

2）newFixedThreadPool 和 newSingleThreadExecutor的主要問題是堆積的請求處理隊列可能會耗費非常大的內(nèi)存，甚至 OOM。

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

3）newCachedThreadPool 和 newScheduledThreadPool:主要問題是線程數(shù)最大數(shù)是 Integer.MAX_VALUE，可能會創(chuàng)建數(shù)量非常多的線程，甚至 OOM。

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