自定义线程池

1、使用有界队列构建线程池

public class MyTask implements Runnable {

	private int taskId;
	private String taskName;
	
	public MyTask(int taskId, String taskName){
		this.taskId = taskId;
		this.taskName = taskName;
	}
	
	public int getTaskId() {
		return taskId;
	}

	public void setTaskId(int taskId) {
		this.taskId = taskId;
	}

	public String getTaskName() {
		return taskName;
	}

	public void setTaskName(String taskName) {
		this.taskName = taskName;
	}

	@Override
	public void run() {
		try {
			System.out.println("执行任务：taskId = " + this.taskId);
			Thread.sleep(4*1000);
			System.out.println("任务"+this.taskId+"，执行完成");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
	}
	
	public String toString(){
		return Integer.toString(this.taskId);
	}
}

/**
 * 拒绝策略
 * 记录日志，返回 http请求数据给客户端
 */
public class MyRejected implements RejectedExecutionHandler{

	public MyRejected(){
	}

    /**
     * @param r  当前任务对象
     * @param executor  当前线程池对象
     */
	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
		System.out.println("队列已满执行自定义拒绝策略：当前被拒绝任务为：" + r.toString());
	}
}

package com.liaoxiang.multithreading3.middle.custom_thread_pool;

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

/**
 * custom_thread_pool：使用有界队列
 * 在使用有界队列时，当有新的任务需要执行的时候：
 *        若线程池实际线程数小于corePoolSize，则优先创建线程，
 * 		  若大于corePoolSize，则会将任务加入队列，
 * 		  若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
 * 		  若线程数大于maximumPoolSize，则执行拒绝策略，或其他自定义方式。
 */
public class CustomThreadPoolExecutor1 {

	public static void main(String[] args) {
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				1, 				//corePoolSize
				2, 		    //maximumPoolSize
				60, 			//当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交
				//核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；
				TimeUnit.SECONDS,			//时间单位为s
				new ArrayBlockingQueue<>(3)	, //使用阻塞有界队列存放等待的线程
				new MyRejected()            //自定义拒绝策略，线程数大于maximumPoolSize时执行
				//new DiscardOldestPolicy() //丢弃最老的，234被加到队列中，2被丢弃，执行第6个任务
				);
		
		MyTask mt1 = new MyTask(1, "任务1");
		MyTask mt2 = new MyTask(2, "任务2");
		MyTask mt3 = new MyTask(3, "任务3");
		MyTask mt4 = new MyTask(4, "任务4");
		MyTask mt5 = new MyTask(5, "任务5");
		MyTask mt6 = new MyTask(6, "任务6");
		
		pool.execute(mt1);
		//coreSize=1，则mt2线程将会被放到队列中
		pool.execute(mt2);
		pool.execute(mt3);
		pool.execute(mt4);
		//当同时执行5个线程时，由于234被放到队列中，当第5个任务进来时，队列已经满了，而线程池的MaxSize=2，则会创建新的线程执行第5个任务
		pool.execute(mt5);
		//当执行6个任务的时候，234同样进队列，创建第2个线程执行第5个任务，因为MaxSize=2，不能再创建新的线程，因此会被拒绝
		pool.execute(mt6);
		//线程任务执行完之后，停止线程
		pool.shutdown();
	}
}

执行流程：

2、使用无界队列创建线程池

package com.liaoxiang.multithreading3.middle.custom_thread_pool;

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

/**
 * custom_thread_pool：使用无界队列
 *      与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务如队列失败的情况。
 *      当有新的任务到来时，系统的线程数小于corePoolSize时，则新建线程执行任务。
 *      若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。
 *      若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存
 */
public class CustomThreadPoolExecutor2 implements Runnable {

    private static AtomicInteger count = new AtomicInteger(0);

    /**
     * 执行线程任务，耗时2s
     */
    @Override
    public void run() {
        try {
            int temp = count.incrementAndGet();
            System.out.println("执行任务" + temp);
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 使用无界队列时，开始执行corePoolSize个任务，其余的加入队列，每次执行完了之后，从队列中取出5个再次运行
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) {

        ExecutorService executor = new ThreadPoolExecutor(
                2,         //core
                4,    //max
                120L,    //2分钟
                TimeUnit.SECONDS,     //时间单位为分钟
                new LinkedBlockingQueue<>());  //使用无界队列
        for (int i = 0; i < 5; i++) {
            executor.execute(new CustomThreadPoolExecutor2());
        }
        executor.shutdown();
    }
}

//开始第一批任务执行
执行任务1
执行任务2
//开始第二批任务执行
执行任务3
执行任务4
//开始第三批任务执行
执行任务5

此时最大线程数设置为2，和4，效果是一样的。猜测可能是因为使用无界队列，当线程数达到核心线程数后，剩余的任务都加到了队列中，所以不再创建新的线程，设置最大线程数无效