How to Limit the Number of Threads and Synchronize with the Main Thread in Java?

Question

How can I limit the number of threads created in Java and wait for the main thread until any one of those threads finds a solution?

// Example of using ExecutorService to limit threads
ExecutorService executorService = Executors.newFixedThreadPool(5); // Limit to 5 threads

Answer

To manage thread limitations and synchronization in Java, you can use the `ExecutorService` and `CountDownLatch` classes. This approach allows you to limit the number of concurrent threads while enabling the main thread to wait until one of the worker threads completes its task.

import java.util.concurrent.*;

public class ThreadLimitExample {
    private static final int THREAD_LIMIT = 5;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_LIMIT);
        CountDownLatch latch = new CountDownLatch(1);

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorService.submit(() -> {
                try {
                    // Simulate computation
                    if (findSolution(taskId)) {
                        System.out.println("Solution found by thread " + taskId);
                        latch.countDown(); // Notify main thread
                    }
                } catch (Exception e) { e.printStackTrace(); }
            });
        }

        latch.await(); // Main thread waits until the solution is found
        executorService.shutdown();
    }

    private static boolean findSolution(int taskId) {
        // Simulate finding solution
        return taskId == 3; // Example condition for demo
    }
}

Causes

Lack of thread control can lead to resource exhaustion.
Main thread may exit before worker threads complete the task.

Solutions

Use `ExecutorService` for managing a fixed thread pool to limit the number of threads.
Implement `CountDownLatch` to synchronize the main thread with worker threads.

Common Mistakes

Mistake: Not shutting down ExecutorService after tasks are completed.

Solution: Always call `executorService.shutdown()` to free up resources.

Mistake: Forgetting to manage thread limits leading to high CPU usage.

Solution: Implement a fixed thread pool using `Executors.newFixedThreadPool(int nThreads)` to impose limits.

Helpers

Java threads
limit number of threads Java
synchronize main thread Java
Java ExecutorService
Java CountDownLatch