Executor源码解析

java.util.concurrent.Executor的主要作用是用来实现工作者线程和任务线程的分离。工作者线程是用来执行任务的线程，任务线程是被工作者线程执行的业务逻辑。Executor其实是一个接口，它包含一个Executor方法，用来执行业务逻辑线程。

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);
}

Executor的3种主要示例

1. 直接在调用者的线程执行

public class Demo {
    public static void main(String[] args) {

        DirectExecutor directExecutor = new DirectExecutor();
        directExecutor.execute(()->{
            System.out.println("DirectExecutor");
        });
    }


}
class DirectExecutor implements Executor{
    @Override
    public void execute(Runnable command) {
        command.run();
    }
}

2. 任务在调用者线程之外的线程执行

public class Demo {
    public static void main(String[] args) {

        ThreadPerTaskExecutor threadPerTaskExecutor = new ThreadPerTaskExecutor();
        threadPerTaskExecutor.execute(()->{
            System.out.println("ThreadPerTaskExecutor");
        });
    }


}
class ThreadPerTaskExecutor implements Executor{
    @Override
    public void execute(Runnable command) {
        new Thread(command).start();
    }
}

3. 排队执行内容

public class Demo {
    public static void main(String[] args) {
        SerialExecutor serialExecutor = new SerialExecutor();
        for (int i = 0; i < 10; i++) {
            int value = i;
            serialExecutor.addTask(() -> {
                System.out.println("任务：" + value);
            });
        }
        serialExecutor.execute(() -> {
            System.out.println("serialExecutor");
        });
    }


}

class SerialExecutor implements Executor {
    final Queue<Runnable> tasks = new ArrayDeque<>();

    SerialExecutor() {
    }

    public synchronized void execute(final Runnable r) {
        if (r != null) {
            r.run();
        }
        scheduleNext();
    }

    public synchronized void addTask(Runnable runnable) {
        tasks.add(runnable);
    }


    protected synchronized void scheduleNext() {
        Runnable active;
        if ((active = tasks.poll()) != null) {
            execute(active);
        }
    }
}