1. package concurrent;
    3. import java.util.concurrent.*;
    5. public class C02_ExThreadpool {
    7.     public static class MyTask implements Runnable{
    8.         private String name;
    9.         public MyTask(String name){ this.name = name; }
    10.         public String getName() { return name; }
    11.         @Override
    12.         public void run() {
    13.             System.out.println(Thread.currentThread().getId() + ":" + name);
    14.             try{ Thread.sleep(1000);}
    15.             catch (InterruptedException e) { e.printStackTrace(); }
    16.         }
    17.     }
    19.     /**
    20.      * .通过自定义的线程工厂可以自定义线程的状态等信息
    21.      */
    22.     public static class MyThreadFactory implements ThreadFactory{
    24.         @Override
    25.         public Thread newThread(Runnable r) {
    26.             Thread t = new Thread(r);
    27. //            t.setDaemon(true);  //设置为守护线程，主线程退出后自动销毁
    28.             System.out.println("create " + t);
    29.             return t;
    30.         }
    31.     }
    34.     public static void main(String[] args) throws InterruptedException{
    35.         /*
    36.         *.创建线程池，并重写线程池的beforeExecute、afterExecute、terminated。
    37.         *.这三个方法默认时空的，但我们可以重写去做一些事情
    38.          */
    39.         ExecutorService es = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MICROSECONDS,
    40.                 new LinkedBlockingDeque<>(), new MyThreadFactory()) {
    41.             @Override
    42.             protected void beforeExecute(Thread t, Runnable r) {
    43.                 System.out.println("准备执行：" + ((MyTask)r).getName());
    44.             }
    46.             @Override
    47.             protected void afterExecute(Runnable r, Throwable t) {
    48.                 System.out.println("执行完成：" + ((MyTask)r).getName());
    49.             }
    51.             @Override
    52.             protected void terminated() {
    53.                 System.out.println("线程池退出");
    54.             }
    55.         };
    56.         //添加任务
    57.         for(int i=0 ; i<3 ; i++){
    58.             es.execute(new MyTask("Task-" + i));
    59.             Thread.sleep(10);
    60.         }
    61.         es.shutdown();  //发送一个信号给线程池，线程池在完成当前所有任务后关闭
    62.     }
    63. }

    console

    1. create Thread[Thread-0,5,main]
    2. 准备执行：Task-0
    3. 11:Task-0
    4. create Thread[Thread-1,5,main]
    5. 准备执行：Task-1
    6. 12:Task-1
    7. create Thread[Thread-2,5,main]
    8. 准备执行：Task-2
    9. 13:Task-2
    10. 执行完成：Task-0
    11. 执行完成：Task-1
    12. 执行完成：Task-2
    13. 线程池退出