向ExecutorService提交Thread实例为何始终处于NEW状态？

你提交给ExecutorService的Thread实例状态始终为NEW的核心原因是：ExecutorService只会调用Runnable的run()方法，不会调用Thread的start()方法。

Thread类本身实现了Runnable接口，当你把Thread对象传给execute()时，ExecutorService会用线程池自身的线程去执行这个Thread的run()方法——相当于在池线程里直接调用了Thread实例的run()逻辑，而非启动这个Thread实例对应的独立线程。因为你从未调用过该Thread实例的start()，它的状态自然一直停留在NEW。

如果需要监控任务执行状态，无需自行创建Thread实例，可通过以下方式实现：

方式1：用Future追踪任务状态 #

提交任务时通过submit()方法获取Future对象，利用Future的方法判断任务完成情况：

public class ThreadStatesFixed {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newSingleThreadExecutor();
        
        Future<?> future1 = service.submit(getRunnable());
        Future<?> future2 = service.submit(getRunnable());

        while (true) {
            boolean task1Done = future1.isDone();
            boolean task2Done = future2.isDone();
            System.out.println("Task 1: " + (task1Done ? "COMPLETED" : "RUNNING") + ", Task 2: " + (task2Done ? "COMPLETED" : "RUNNING"));
            Thread.sleep(1000);
            if (task1Done && task2Done) break;
        }

        service.shutdown();
        System.out.println("Program complete.");
    }

    static Runnable getRunnable() {
        return () -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        };
    }
}

方式2：自定义带状态的Runnable #

若需要更细粒度的状态监控，可自行实现包含状态标记的Runnable：

class TrackableRunnable implements Runnable {
    private volatile State state = State.PENDING;
    private final Runnable delegate;

    public TrackableRunnable(Runnable delegate) {
        this.delegate = delegate;
    }

    @Override
    public void run() {
        state = State.RUNNING;
        try {
            delegate.run();
            state = State.COMPLETED;
        } catch (Exception e) {
            state = State.FAILED;
            throw e;
        }
    }

    public State getState() {
        return state;
    }

    public enum State {
        PENDING, RUNNING, COMPLETED, FAILED
    }
}

// 使用示例
public class ThreadStatesFixed2 {
    public static void main(String[] args) throws InterruptedException {
        TrackableRunnable task1 = new TrackableRunnable(getRunnable());
        TrackableRunnable task2 = new TrackableRunnable(getRunnable());

        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(task1);
        service.execute(task2);

        while (true) {
            System.out.println("Task 1: " + task1.getState() + ", Task 2: " + task2.getState());
            Thread.sleep(1000);
            boolean taskComplete = task1.getState() == TrackableRunnable.State.COMPLETED &&
                    task2.getState() == TrackableRunnable.State.COMPLETED;
            if (taskComplete) break;
        }

        service.shutdown();
        System.out.println("Program complete.");
    }

    static Runnable getRunnable() {
        return () -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        };
    }
}

ExecutorService的设计初衷是管理线程池、复用线程执行任务，而非启动你自行创建的Thread实例。直接提交Thread对象不仅无法启动目标线程，还会造成概念混淆，应始终通过提交Runnable/Callable让线程池执行任务，再通过Future或自定义状态追踪任务状态。

内容的提问来源于stack exchange，提问作者sam