ThreadPoolExecutor

ThreadPoolExecutor

jdk自带的线程池ThreadPoolExecutor

全参构造方法

  public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {

各个参数

int corePoolSize

核心线程的数量，核心线程创建后不会被销毁。

int maximumPoolSize

最大线程数量，在没有任务可以执行的情况下除核心线程的线程会被销毁

long keepAliveTime

其他线程在没有任务情况下可以存活的时间

TimeUnit unit

等待时间单位

BlockingQueue workQueue

阻塞队列，存放任务的队列，当核心线程满了以后，任务会放到队列当中去

ThreadFactory threadFactory

线程工厂，创建线程

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     	构造一个行的线程，实例化优先级，名称，守护状态等属性
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

线程工厂接口，实现该接口就可以创建自己的线程工厂，该接口主要实现的是创建线程的方法。

线程池默认工厂DefaultThreadFactory

// 创建线程
// 设置线程组
// 设置线程名称
// 把任务放到线程中去
// 不为守护线程，优先级为Thread.NORM_PRIORITY
// Thread.NORM_PRIORITY = 5
public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

RejectedExecutionHandler handler

拒绝策略，当所有线程都在执行任务，并且阻塞队列也满的时候，会执行拒绝策略。对新加的任务进行操作。

// 拒绝策略接口，实现接口中的方法，对新增加的任务进行处理。
public interface RejectedExecutionHandler {

    /**
     * Method that may be invoked by a {@link ThreadPoolExecutor} when
     * {@link ThreadPoolExecutor#execute execute} cannot accept a
     * task.  This may occur when no more threads or queue slots are
     * available because their bounds would be exceeded, or upon
     * shutdown of the Executor.
     *
     * <p>In the absence of other alternatives, the method may throw
     * an unchecked {@link RejectedExecutionException}, which will be
     * propagated to the caller of {@code execute}.
     *
     * @param r the runnable task requested to be executed
     * @param executor the executor attempting to execute this task
     * @throws RejectedExecutionException if there is no remedy
     */
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

线程池默认有四种拒绝策略

AbortPolicy 中止策略，如果任务满了，直接抛出异常

public static class AbortPolicy implements RejectedExecutionHandler {
    /**
     * Creates an {@code AbortPolicy}.
     */
    public AbortPolicy() { }

    /**
     * Always throws RejectedExecutionException.
     *
     * @param r the runnable task requested to be executed
     * @param e the executor attempting to execute this task
     * @throws RejectedExecutionException always
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

DiscardPolicy 丢弃策略，任务满了什么也不做

/**
 * A handler for rejected tasks that silently discards the
 * rejected task.
 */
public static class DiscardPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code DiscardPolicy}.
     */
    public DiscardPolicy() { }

    /**
     * Does nothing, which has the effect of discarding task r.
     *
     * @param r the runnable task requested to be executed
     * @param e the executor attempting to execute this task
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    	// 什么也不做
    }
}

DiscardOldestPolicy丢弃最旧的任务，把新任务加进去

/**
 * A handler for rejected tasks that discards the oldest unhandled
 * request and then retries {@code execute}, unless the executor
 * is shut down, in which case the task is discarded.
 */
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code DiscardOldestPolicy} for the given executor.
     */
    public DiscardOldestPolicy() { }

    /**
     * Obtains and ignores the next task that the executor
     * would otherwise execute, if one is immediately available,
     * and then retries execution of task r, unless the executor
     * is shut down, in which case task r is instead discarded.
     *
     * @param r the runnable task requested to be executed
     * @param e the executor attempting to execute this task
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    	// 判断线程时是否关闭
    	// 在线程队列中取出尾部(最老的任务)
    	// 执行任务，把任务加到队列头部
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

执行任务

通过Executor接口的execute方法执行任务

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

简单运用

ExecutorService executorService  = new ThreadPoolExecutor(1,1,0L,TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        for (int i = 0; i < 10; i++) {
            final int j = i;
            // 执行任务
            executorService.execute(()->{
                try {
                    TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 打印
                System.out.println(Thread.currentThread().getName() + " print " + j);
            });
        }
//        关闭线程池
        executorService.shutdown();