自定义线程工厂与拒绝策略的实现

继上一篇由浅及深认识线程池，本篇文章来写自定义线程工厂与拒绝策略

上一篇文章链接：由浅及深认识线程池

一：自定义线程工厂

创建 MyThreadFactory

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义线程工厂，实现自定义线程命名
 *
 * @author miao
 */
public class MyThreadFactory implements ThreadFactory {

    private final AtomicInteger nextId = new AtomicInteger(1);

    private final String namePrefix;

    /**
     * 定义线程组名称，在使用jstack来排查堆栈问题时，非常有帮助
     *
     * @param whatFeatureOfGroup
     */
    public MyThreadFactory(String whatFeatureOfGroup) {
        namePrefix = "MyThreadFactory's " + whatFeatureOfGroup + "-Worker-";
    }

    @Override
    public Thread newThread(Runnable task) {

        String name = namePrefix + nextId.getAndIncrement();
        Thread thread = new Thread(null, task, name, 0);

        System.out.println(thread.getName());

        return thread;
    }
}

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

/**
 * @author miao
 */
public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {

        MyThreadFactory myFactory = new MyThreadFactory("中国杭州-交易系统");

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 60,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(), myFactory);

        threadPoolExecutor.execute(()->{
            
        });
    }
}

二：自定义拒绝策略

创建 MyRejectHandle

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 自定义拒绝策略
 *
 * @author miao
 */
public class MyRejectHandle implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {

        System.out.println("you task is rejected." + executor.toString());
    }
}

创建 MyTask

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 任务执行体
 *
 * @author miao
 */
public class MyTask implements Runnable {
    private final AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {

        System.out.println("running_" + count.getAndIncrement());
    }
}

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

/**
 * @author miao
 */
public class ThreadPoolExecutorDemo {

    private static final Integer FOR_SIZE = 200;

    public static void main(String[] args) {

        MyThreadFactory factory1 = new MyThreadFactory("中国杭州-交易系统");
        MyThreadFactory factory2 = new MyThreadFactory("中国杭州-搜索系统");

        MyRejectHandle handle = new MyRejectHandle();
        LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(2);

        //核心线程 1，最大线程 2 ，为了保证触发rejectHandle
        ThreadPoolExecutor executorFirst = new ThreadPoolExecutor(1, 2, 60,
                TimeUnit.SECONDS, queue, factory1, handle);
        ThreadPoolExecutor executorSecond = new ThreadPoolExecutor(1, 2, 60,
                TimeUnit.SECONDS, queue, factory2, handle);

        Runnable task = new MyTask();

		//创建四百个任务线程
        for (int i = 0; i < FOR_SIZE; i++) {

            executorFirst.execute(task);
            executorSecond.execute(task);

        }
    }

}

当任务被拒绝的时候，拒绝策略会打印出当前线程的大小已经达到了maximumPoolSize=2，且队列已满，完成的任务数提示

下一篇：线程池部分源码详解

参考：《码出高效》