TestThreadPoolExecutorMain

package core.test.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * ThreadPoolExecutor 線程池
 * 構造函數參數
 * 
 * 1、corePoolSize 核心線程數大小，當線程數 < corePoolSize ，會創建線程執行 runnable
 * 
 * 2、maximumPoolSize 最大線程數， 當線程數 >= corePoolSize的時候，會把 runnable 放入 workQueue中
 * 
 * 3、keepAliveTime 保持存活時間，當線程數大於corePoolSize的空閑線程能保持的最大時間。
 * 
 * 4、unit 時間單位
 * 
 * 5、workQueue 保存任務的阻塞隊列
 * 
 * 6、threadFactory 創建線程的工廠
 * 
 * 7、handler 拒絕策略
 * 
 * 任務執行順序    （核心線程數，阻塞隊列，最大線程數，異常）
 * 
 * 1、當線程數小於 corePoolSize時，創建線程執行任務。
 * 
 * 2、當線程數大於等於 corePoolSize並且 workQueue 沒有滿時，放入workQueue中
 * 
 * 3、線程數大於等於 corePoolSize並且當 workQueue 滿時，新任務新建線程運行，線程總數要小於 maximumPoolSize
 * 
 * 4、當線程總數等於 maximumPoolSize 並且 workQueue 滿了的時候執行 handler 的
 * rejectedExecution。也就是拒絕策略。
 * 
 * 四個拒絕策略
 * 
 * ThreadPoolExecutor默認有四個拒絕策略：
 * 
 * 1、ThreadPoolExecutor.AbortPolicy() 直接拋出異常RejectedExecutionException
 * 
 * 2、ThreadPoolExecutor.CallerRunsPolicy() 直接調用run方法並且阻塞執行
 * 
 * 3、ThreadPoolExecutor.DiscardPolicy() 直接丟棄後來的任務
 * 
 * 4、ThreadPoolExecutor.DiscardOldestPolicy() 丟棄在隊列中隊首的任務
 * 
 * 當然可以自己繼承RejectedExecutionHandler來寫拒絕策略.
 * 
 * 
 
@author chenyd 2017年10月24日
 */
public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        Long currentTimeMillis = System.currentTimeMillis();
        // new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime,
        // unit, workQueue)
        ThreadPoolExecutor threadpool = new
 
 ThreadPoolExecutor(3, 10, 3, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(3));

        for (int i = 0; i < 100; i++) {

            try {
                String task = "task=" + i;
                System.out.println("創建任務並提交到線程池：" + task);
                threadpool.execute(
 
new ThreadPoolTast(task));

                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

        try {
            threadpool.shutdown();
            boolean loop = true;

            do {
                loop = !threadpool.awaitTermination(2, TimeUnit.SECONDS);
            } while (loop);

            if (loop != true) {
                System.out.println("所有線程執行完畢");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("耗時：" + (System.currentTimeMillis() - currentTimeMillis));
        }

    }
}

ThreadPoolTast

package core.test.threadpool;

import java.io.Serializable;

public class ThreadPoolTast implements Runnable, Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    
    private Object attachData;
    
    public ThreadPoolTast(Object tasks) {
        this.attachData=tasks;
    }

    @Override
    public void run() {
        
        try {
            System.out.println("開始執行任務："+attachData+"任務，使用線程池，線程名稱："+Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        attachData=null;
        
    }
}

參考鏈接：

Java四種線程池的使用 http://cuisuqiang.iteye.com/blog/2019372

ThreadPoolExecutor 線程池