定制并发类

定制ThreadPoolExecutor ，覆盖相关方法

package mytest;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolExecutor extends ThreadPoolExecutor {
    private ConcurrentHashMap<String, Date> startTimes;

    public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        startTimes = new ConcurrentHashMap<>();
    }

    @Override
    public void shutdown() {
        System.out.println("MyExecutor:Going to shutdown.\n");
        System.out.println("MyExecutor:Executed Completed tasks :" + getCompletedTaskCount());
        System.out.println("MyExecutor:Running tasks:" + getActiveCount());
        System.out.println("MyExecutor:Pending tasks:" + getQueue().size());
        super.shutdown();
    }

    @Override
    public void beforeExecute(Thread t, Runnable r) {
        System.out.println("MyExecutor:A task is beginning:" + t.getName() + ";Runnable hashCode:" + r.hashCode());
        startTimes.put(String.valueOf(r.hashCode()), new Date());
    }

    @Override
    public void afterExecute(Runnable r, Throwable t) {
        Future<?> result = (Future<?>) r;
        try {
            System.out.println("**********************************************************************");
            System.out.println("MyExecutor:A task is finishing");
            System.out.println("MyExecutor:Result:" + result.get());
            Date startTime = startTimes.remove(String.valueOf(r.hashCode()));
            Date finishDate = new Date();
            System.out.println("MyExecutor:Duration:" + (finishDate.getTime() - startTime.getTime()));
            System.out.println("**********************************************************************");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        startTimes.put(String.valueOf(r.hashCode()), new Date());

    }

    static class SleepSecondTask implements Callable<String> {

        @Override
        public String call() throws Exception {
            TimeUnit.SECONDS.sleep(2);
            return new Date().toString();
        }

    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(2, 4, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<Runnable>());
        List<Future<String>> result = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            SleepSecondTask task = new SleepSecondTask();
            Future<String> submit = myThreadPoolExecutor.submit(task);
            result.add(submit);
        }
        for (int i = 0; i < 5; i++) {
            String object = result.get(i).get();
            System.out.println("Main:Result for task " + i + ";result:" + object);
        }
        myThreadPoolExecutor.shutdown();
        for (int i = 5; i < 10; i++) {
            String object = result.get(i).get();
            System.out.println("Main:Result for task " + i + ";result:" + object);
        }
        myThreadPoolExecutor.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("Main: End of the program");
    }

}

带优先级的线程池

package mytest;

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

//有序组合队列
//当插入元素时，PriorityBlockingQueue使用compareTo方法来决定插入元素的位置，元素越大越靠后
public class PriorityBlockingExecutor {
    static class MyPriorityTask implements Runnable, Comparable<MyPriorityTask> {
        private String thread;
        private int priority;

        public MyPriorityTask(String thread, int priority) {
            this.thread = thread;
            this.priority = priority;
        }

        public String getThread() {
            return thread;
        }

        public int getPriority() {
            return priority;
        }

        @Override
        public int compareTo(MyPriorityTask o) {
            if (this.priority > o.getPriority()) {
                return -1;
            } else if (this.priority < o.getPriority()) {
                return 1;
            }
            return 0;
        }

        @Override
        public void run() {
            System.out.println("MyPriorityTask:currentThread:" + Thread.currentThread().getName() + ";name:" + thread + ";Priority:" + priority);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new PriorityBlockingQueue<Runnable>());
        for (int i = 0; i < 4; i++) {
            MyPriorityTask task = new MyPriorityTask("Task " + i, i);
            executor.execute(task);
        }
        TimeUnit.SECONDS.sleep(1);
        for (int i = 4; i < 8; i++) {
            MyPriorityTask task = new MyPriorityTask("Task " + i, i);
            executor.execute(task);
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("Main :End of the program.");
    }
}

后四个执行前，对应的优先级为日志中前两个，后面开始执行时，优先级被打破
优先级越高越早执行

MyPriorityTask:currentThread:pool-1-thread-2;name:Task 1;Priority:1
MyPriorityTask:currentThread:pool-1-thread-1;name:Task 0;Priority:0
MyPriorityTask:currentThread:pool-1-thread-1;name:Task 7;Priority:7
MyPriorityTask:currentThread:pool-1-thread-2;name:Task 6;Priority:6
MyPriorityTask:currentThread:pool-1-thread-1;name:Task 5;Priority:5
MyPriorityTask:currentThread:pool-1-thread-2;name:Task 4;Priority:4
MyPriorityTask:currentThread:pool-1-thread-1;name:Task 3;Priority:3
MyPriorityTask:currentThread:pool-1-thread-2;name:Task 2;Priority:2
Main :End of the program.

尝尝ThreadFactory的味道

package mytest;

import java.util.Date;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

public class ThreadFactoryTest {
    static class MyThread extends Thread {
        private Date createDate;
        private Date startDate;
        private Date finishDate;

        public MyThread(Runnable target, String name) {
            super(target, name);
            createDate = new Date();
        }

        @Override
        public void run() {
            startDate = new Date();
            super.run();
            finishDate = new Date();
        }

        @Override
        public String toString() {
            return getName() + ":create date:" + createDate + ";running time:" + (finishDate.getTime() - startDate.getTime() + " millieseconds");
        }
    }

    static class MyThreadFactory implements ThreadFactory {
        private int counter;
        private String prefix;

        public MyThreadFactory(String prefix) {
            this.prefix = prefix;
            counter = 1;
        }

        @Override
        public Thread newThread(Runnable r) {
            MyThread myThread = new MyThread(r, prefix + "-" + counter);
            counter++;
            return myThread;
        }
    }

    static class MyTask implements Runnable {

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        MyThreadFactory myThreadFactory = new MyThreadFactory("MyThreadFactory");
        MyTask myTask = new MyTask();
        Thread thread = myThreadFactory.newThread(myTask);
        thread.start();
        thread.join();
        System.out.println(thread);
    }
}