自定义线程池的一些理解

    ThreadPoolExecutor pool = new ThreadPoolExecutor(1//核心线程数量
                , 3//最大线程数量
                , 60//线程存活时间
                , TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2)//有界队列
                , new ThreadFactory() {
                    
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread th = new Thread(r,"my_thread");
                        if(th.getPriority() != Thread.NORM_PRIORITY){
                            th.setPriority(Thread.NORM_PRIORITY);
                        }
                        if(th.isDaemon()){
                            th.setDaemon(false);
                        }
                        return th;
                    }
                }, new RejectedExecutionHandler() {
                    
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.err.println("当前任务已经被拒绝："+r);
                        
                    }
                });

 

        Task t1 = new Task(1,1);
        Task t2 = new Task(2,2);
        Task t3 = new Task(3,3);
        Task t4 = new Task(4,4);
        Task t5 = new Task(5,5);
        Task t6 = new Task(6,6);
        
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.shutdown();

 

public class Task implements Runnable{
    
    private int id;
    
    private int count;
    

    public Task(int id, int count) {
        super();
        this.id = id;
        this.count = count;
    }

    @Override
    public void run() {
        System.err.println("处理线程任务：" + this.id);
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

    @Override
    public String toString() {
        return "Task [id=" + id + ", count=" + count + "]";
    }
}
 

从代码的运行结果来看

处理线程任务：1
处理线程任务：5
处理线程任务：4
当前任务已经被拒绝：Task [id=6, count=6]
处理线程任务：2
处理线程任务：3
 

当执行线程t1的时候，直接使用初始化的核心线程执行任务

当执行线程t2的时候，此时线程的数量大于核心线程，则讲t2线程加入有界队列中

当执行线程t3的时候，此时线程的数量大于核心线程 ，则t3线程加入有界队列中

当执行线程t4的时候，此时队列容量已满，此时的线程数量是还没有超过最大线程，则启用一个新的线程执行任务

当执行线程t5的时候，此时队列容量已满，此时的线程数量是还没有超过最大线程，则启用一个新的线程执行任务

当执行线程t6的时候，此时队列容量已满，此时的线程数量超过最大线程，则启用自己的拒绝策略

 

注意的是，如果把ArrayBlockingQueue 有界队列，换成无界队列LinkedBlockingQueue 则线程池的工作原理是

当线程的数量不超过核心线程的数量，启用线程去执行任务，当线程数量大于核心线程的数量的时候，则直接加入无界队列中等待被执行，此时后的最大线程数量的设置其实是没有作用的