ThreadPoolExecutor应用

任务类型

1、java.lang.Runnable

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

2、java.util.concurrent.Callable

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

任务提交

方式

1、java.util.concurrent.ThreadPoolExecutor#execute

　　public void execute(Runnable command) {}

2、java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable)

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

3、java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable, T)　　

public <T> Future<T> submit(Runnable task, T result) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task, result);
    execute(ftask);
    return ftask;
}

4、java.util.concurrent.AbstractExecutorService#submit(java.util.concurrent.Callable<T>)

public <T> Future<T> submit(Callable<T> task) {
       if (task == null) throw new NullPointerException();
       RunnableFuture<T> ftask = newTaskFor(task);
       execute(ftask);
       return ftask;
   }

任务提交拒绝策略

1、java.util.concurrent.ThreadPoolExecutor#execute

// command the task to execute
// @throws RejectedExecutionException at discretion of {@code 
// RejectedExecutionHandler}, if the task cannot be accepted for execution
 
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);                                         -- 拒绝
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);                                            -- 拒绝
    }

2、java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable)

/**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);  -- 将Runnable包装
        execute(ftask);  -- java.util.concurrent.ThreadPoolExecutor#execute
        return ftask;
    }
 
 
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

3、java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable, T)

/**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result); // 将Runnable包装
        execute(ftask);    // java.util.concurrent.ThreadPoolExecutor#execute
        return ftask;
    }
 
 
 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

4、java.util.concurrent.AbstractExecutorService#submit(java.util.concurrent.Callable<T>)

/**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);  // 将Callable包装
        execute(ftask);  //java.util.concurrent.ThreadPoolExecutor#execute
        return ftask;
    }
 
 
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

　　【execute、submit时，可能会有异常，需要手动try...catch...】

任务线程异常

java.util.concurrent.ThreadPoolExecutor#execute

public class ThreadPoolExecutor extends AbstractExecutorService {
 
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable{
 
        public void run() {
            runWorker(this);
        }
 
    }
 
 
     final void runWorker(Worker w) {
 
        ...    
        beforeExecute(wt, task);
        run...
        throw...
        ...
        afterExecute(task, thrown);
        ...
 
    }
}

　　任务线程执行异常，将由 java.lang.Thread.UncaughtExceptionHandler 进行处理

// When a thread is about to terminate due to an uncaught exception
// the Java Virtual Machine will query the thread for its
// UncaughtExceptionHandler using getUncaughtExceptionHandler 
// and will invoke the handler's uncaughtException method, 
// passing the thread and the exception as arguments.
 
@FunctionalInterface
    public interface UncaughtExceptionHandler {
        /**
         * Method invoked when the given thread terminates due to the
         * given uncaught exception.
         * <p>Any exception thrown by this method will be ignored by the
         * Java Virtual Machine.
         * @param t the thread
         * @param e the exception
         */
        void uncaughtException(Thread t, Throwable e);
    }

/**
     * Dispatch an uncaught exception to the handler. This method is
     * intended to be called only by the JVM.
     */
    private void dispatchUncaughtException(Throwable e) {
        getUncaughtExceptionHandler().uncaughtException(this, e);
    }

　　当任务线程异常，JVM会调用dispatchUncaughtException处理异常

　　用户可以自定义UncaughtExceptionHandler，实现UncaughtExceptionHandler，通过java.lang.Thread#setUncaughtExceptionHandler自定义线程异常处理器

public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        checkAccess();
        uncaughtExceptionHandler = eh;
    }

java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable)/submit(java.lang.Runnable, T)/submit(java.util.concurrent.Callable<T>)

　　submit方式，将Runnable、Callble包装成java.util.concurrent.FutureTask，任务执行体就是FutureTask的run方法

public interface RunnableFuture<V> extends Runnable, Future<V> {
 
     void run();
 
}
 
 
public class FutureTask<V> implements RunnableFuture<V> {
 
    // The result to return or exception to throw from get() 
    private Object outcome;
 
    public void run() {
 
        ...
        try {
                    result = c.call();   // 任务执行
                    ...
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);      // 任务异常处理
                }
        ....
 
    }
 
 
    protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;   // 将异常信息存储到outcome
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }
 
 
     
 
 
}

　　当调用java.util.concurrent.FutureTask#get()，任务线程的异常就会获取到

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);    // 获取异常信息
    }
 
 
/**
     * Returns result or throws exception for completed task.
     *
     * @param s completed state value
     */
    @SuppressWarnings("unchecked")
    private V report(int s) throws ExecutionException {
        Object x = outcome;     // 从outcome获取异常信息
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }