Java ExecutorService四種線程池及ThreadPoolExecutor機制

1、爲何使用線程池java

使用new Thread執行多個線程有以下一些問題:數據庫

每次new Thread新建對象性能差。
線程缺少統一管理,可能無限制新建線程,相互之間競爭,及可能佔用過多系統資源致使死機或oom。
缺少更多功能,如定時執行、按期執行、線程中斷。
相比new Thread,Java提供的四種線程池的好處在於:緩存

重用存在的線程,減小對象建立、消亡的開銷,性能佳。
可有效控制最大併發線程數,提升系統資源的使用率,同時避免過多資源競爭,避免堵塞。
提供定時執行、按期執行、單線程、併發數控制等功能。

併發

2、怎麼使用線程池ide

java中提供的四種線程池都是Executors提供的,共計四種。性能

1, newCachedThreadPoolthis

建立一個可緩存線程池,若是線程池長度超過處理須要,可靈活回收空閒線程,若無可回收,則新建線程。示例代碼以下:spa

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}線程

cachedThreadPool.execute(new Runnable() {code

@Override
public void run() {
System.out.println(index);
}
});
}

線程池爲無限大,當執行第二個任務時第一個任務已經完成,會複用執行第一個任務的線程,而不用每次新建線程。

2, newFixedThreadPool

建立一個定長線程池,可控制線程最大併發數,超出的線程會在隊列中等待。示例代碼以下:

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
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.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

由於線程池大小爲3,每一個任務輸出index後sleep 2秒,因此每兩秒打印3個數字。 定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()。可參考PreloadDataCache。

3, newScheduledThreadPool

建立一個定長線程池,支持定時及週期性任務執行。延遲執行示例代碼以下:

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

表示延遲3秒執行。

按期執行示例代碼以下:

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

表示延遲1秒後每3秒執行一次。

4, newSingleThreadExecutor

建立一個單線程化的線程池,它只會用惟一的工做線程來執行任務,保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼以下:

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(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

結果依次輸出,至關於順序執行各個任務。 現行大多數GUI程序都是單線程的。Android中單線程可用於數據庫操做,文件操做,應用批量安裝,應用批量刪除等不適合併發但可能IO阻塞性及影響UI線程響應的操做。

3、分析四種線程池

先看下四種線程池的構建代碼:

1, newCachedThreadPool

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

2, newFixedThreadPool

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

3, newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

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

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

4, newSingleThreadExecutor

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

從上面能夠看出這四種構造方法最終都是返回了ThreadPoolExecutor對象,下面重點分析下它,看下它的構造方法:

public ThreadPoolExecutor(int corePoolSize,//核心線程池大小
int maximumPoolSize,//最大線程池大小
long keepAliveTime,//線程池中超過corePoolSize數目的空閒線程最大存活時間;能夠allowCoreThreadTimeOut(true)成爲核心線程的有效時間
TimeUnit unit,//keepAliveTime的時間單位
BlockingQueue<Runnable> workQueue,//阻塞任務隊列
ThreadFactory threadFactory,//線程工廠
RejectedExecutionHandler handler) {//當提交任務數超過maxmumPoolSize+workQueue之和時,任務會交給RejectedExecutionHandler來處理
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

重點講解:

其中比較容易讓人誤解的是:corePoolSize,maximumPoolSize,workQueue之間關係。

當線程池小於corePoolSize時,新提交任務將建立一個新線程執行任務,即便此時線程池中存在空閒線程。
當線程池達到corePoolSize時,新提交任務將被放入workQueue中,等待線程池中任務調度執行。
當workQueue已滿,且maximumPoolSize>corePoolSize時,新提交任務會建立新線程執行任務。
當提交任務數超過maximumPoolSize時,新提交任務由RejectedExecutionHandler處理。
當線程池中超過corePoolSize線程,空閒時間達到keepAliveTime時,關閉空閒線程。
當設置allowCoreThreadTimeOut(true)時,線程池中corePoolSize線程空閒時間達到keepAliveTime也將關閉。
那麼學會使用ThreadPoolExecutor的參數後,咱們就能夠不用侷限於最上面那四種線程池,能夠按照須要來構建本身的線程池。

另外,經過ThreadFactory能夠實現對線程的命名,具體代碼以下:

executor = Executors.newCachedThreadPool(new ThreadFactory() {

final AtomicInteger threadNumber = new AtomicInteger(1);

public Thread newThread(Runnable runnable) { // Use our own naming scheme for the threads. Thread thread = new Thread(Thread.currentThread().getThreadGroup(), runnable, "pool-spark" + threadNumber.getAndIncrement(), 0); //這裏實現命名 // Make workers daemon threads. thread.setDaemon(true); if (thread.getPriority() != Thread.NORM_PRIORITY) { thread.setPriority(Thread.NORM_PRIORITY); } return thread; } });

相關文章
相關標籤/搜索