Understanding Java Thread Creation, Thread Pools, and Optimization Strategies

The article begins by outlining the interview question’s purpose: to assess knowledge of thread creation methods, problems caused by creating many threads, and appropriate optimizations such as thread pools.

Thread Creation Methods

Java provides two primary ways to create a new thread of execution: extending Thread or implementing Runnable. The JDK documentation states that these are the only two official approaches; a third, often mentioned "Callback", is actually just a form of Runnable.

/**
 * There are two ways to create a new thread of execution. One is to
 * declare a class to be a subclass of Thread.
 * The other way to create a thread is to declare a class that
 * implements the Runnable interface.
 */
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("test MyThread run");
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("test MyRunnable run");
    }
}

For tasks that need a return value, Callable can be used together with FutureTask:

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(10000);
        return "test MyCallable run";
    }
}

FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
new Thread(futureTask).start();
String result = futureTask.get();

What Happens When Thread.start() Is Called?

The Thread.start() method performs state checks and then invokes a native method start0(). This native method maps to the JVM entry point JVM_StartThread, which creates a native thread via pthread_create on POSIX systems.

public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    group.add(this);
    boolean started = false;
    try {
        start0(); // native method
        started = true;
    } finally {
        if (!started) {
            group.threadStartFailed(this);
        }
    }
}

private native void start0();

The native entry creates a JavaThread object, which ultimately calls pthread_create. The new OS thread runs thread_native_entry, which invokes the Java thread’s run() method via the JavaCalls module.

Costs of Creating Many Threads

Time overhead : Thread creation and destruction consume CPU cycles.

Memory overhead : Each thread allocates stack space; excessive threads can cause memory pressure and even OOM.

CPU overhead : Too many threads increase context‑switching, which can outweigh the work the threads perform.

Optimization Strategies

Tasks are classified as CPU‑bound or I/O‑bound. For CPU‑bound work, limit concurrent threads to the number of CPU cores (plus one). For I/O‑bound work, you can run roughly twice the number of cores.

When many threads are unavoidable, use a thread pool to reuse existing threads and reduce creation cost. The JDK’s ThreadPoolExecutor provides flexible configuration.

public class ThreadPoolService {
    private ThreadPoolExecutor mThreadPoolExecutor;
    private static volatile ThreadPoolService sInstance = null;
    private final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() + 1;
    private final int MAXIMUM_POOL_SIZE = Math.max(CORE_POOL_SIZE, 10);
    private final long KEEP_ALIVE_TIME = 2;
    private final TimeUnit UNIT = TimeUnit.SECONDS;
    private final BlockingQueue<Runnable> WORK_QUEUE = new LinkedBlockingDeque<>();
    private final ThreadFactory THREAD_FACTORY = Executors.defaultThreadFactory();
    private final RejectedExecutionHandler REJECTED_HANDLER = new ThreadPoolExecutor.AbortPolicy();

    private ThreadPoolService() {}

    public static ThreadPoolService getInstance() {
        if (sInstance == null) {
            synchronized (ThreadPoolService.class) {
                if (sInstance == null) {
                    sInstance = new ThreadPoolService();
                    sInstance.initThreadPool();
                }
            }
        }
        return sInstance;
    }

    private void initThreadPool() {
        try {
            mThreadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAXIMUM_POOL_SIZE,
                KEEP_ALIVE_TIME,
                UNIT,
                WORK_QUEUE,
                THREAD_FACTORY,
                REJECTED_HANDLER);
        } catch (Exception e) {
            LogUtil.printStackTrace(e);
        }
    }

    public void post(Runnable runnable) {
        mThreadPoolExecutor.execute(runnable);
    }

    public <T> Future<T> post(Callable<T> callable) {
        RunnableFuture<T> task = new FutureTask<>(callable);
        mThreadPoolExecutor.execute(task);
        return task;
    }
}

By configuring core pool size, maximum pool size, keep‑alive time, and appropriate rejection policies, developers can balance resource usage and throughput for both CPU‑intensive and I/O‑intensive workloads.