How to Test Java ExecutorService Without Thread.sleep(): Reliable Strategies

In Java, using

ExecutorService

to manage asynchronous tasks, unit tests need to verify execution status, order, or results. Relying on

Thread.sleep()

is unreliable and slows tests.

ExecutorService testing challenges

ExecutorService

is a thread‑pool framework for efficiently managing asynchronous tasks. In the WebSocket product‑query system, it can send parallel requests or handle push messages. Unit testing aims to verify that tasks execute correctly, results match expectations, and concurrent logic is reliable.

Testing challenges:

Non‑determinism : Fixed sleep time may be insufficient or wasteful, especially when network latency varies.

Performance degradation : Fixed sleep cannot adapt to dynamic task durations, affecting test efficiency.

Concurrency complexity : In multithreaded environments, ensuring task order and result correctness while avoiding data races is essential.

The article introduces three more reliable alternatives:

Future.get()

,

CountDownLatch

, and

shutdown()/awaitTermination()

.

Future

Future.get()

blocks the main thread until the task completes, returning the result or throwing an exception, making it suitable for scenarios that need to verify return values.

Example code simulating a product‑query task and verifying the WebSocket client response:

<code>package org.funtester.performance.books.chapter05.section7;

import org.funtester.performance.books.chapter05.section2.JavaWebSocketClient;
import org.junit.jupiter.api.Test;
import com.alibaba.fastjson.JSONObject;
import java.net.URI;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * FunTester uses Future.get() to test WebSocket client
 */
public class WebSocketFutureTest {

    // JUnit test method
    @Test
    public void testWebSocketQuery() throws Exception {
        // Create single‑thread executor
        ExecutorService executor = Executors.newSingleThreadExecutor();
        // Construct WebSocket server URI
        URI uri = new URI("ws://localhost:12345/websocket/FunTester");
        // Create WebSocket client instance
        JavaWebSocketClient client = new JavaWebSocketClient(uri);
        // Connect to server
        client.connect();

        // Submit asynchronous task, send request and wait for response
        Future<JSONObject> future = executor.submit(() -> {
            JSONObject params = new JSONObject();
            params.put("name", "西瓜");
            params.put("index", 1);
            // Send parameters to server
            client.send(params);

            // Simulate asynchronous wait, poll for message
            for (int i = 0; i < 10; i++) {
                if (client.getLastMessage() != null) {
                    // Parse and return when message received
                    return JSONObject.parseObject(client.getLastMessage());
                }
                Thread.sleep(100); // poll every 100ms
            }
            return null;
        });

        // Block until task completes and get result
        JSONObject result = future.get();
        // Assert returned fields
        assertEquals("西瓜", result.getString("Name"));
        assertEquals(45, result.getInteger("Price"));
        // Close client and executor
        client.close();
        executor.shutdown();
    }
}
</code>

Code analysis:

Applicable scenario : Verifying task return values, such as product‑query responses.

Advantages :

Future.get()

ensures task completion, avoiding manual sleep.

Considerations : Must handle possible

InterruptedException

and

ExecutionException

. In the example, a mock server can simulate responses.

Limitations : If the task runs long,

get()

blocks the test thread, potentially affecting efficiency.

CountDownLatch

CountDownLatch

is a synchronization tool that allows the main thread to wait for a specified number of tasks to complete, suitable for multi‑task collaboration scenarios.

Example code testing multiple concurrent WebSocket client queries:

<code>package org.funtester.performance.books.chapter05.section7;

import org.funtester.performance.books.chapter05.section2.JavaWebSocketClient;
import org.junit.jupiter.api.Test;
import com.alibaba.fastjson.JSONObject;
import java.net.URI;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * FunTester uses CountDownLatch to test WebSocket client
 */
public class WebSocketCountDownLatchTest {

    @Test
    public void testMultipleWebSocketQueries() throws Exception {
        // Fixed thread pool of size 2
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // Latch counting down from 2
        CountDownLatch latch = new CountDownLatch(2);
        // WebSocket server URI
        URI uri = new URI("ws://localhost:12345/websocket/FunTester");
        // First client with overridden onMessage
        JavaWebSocketClient client1 = new JavaWebSocketClient(uri) {
            @Override
            public void onMessage(String s) {
                super.onMessage(s);
                latch.countDown(); // decrement on response
            }
        };
        // Second client with overridden onMessage
        JavaWebSocketClient client2 = new JavaWebSocketClient(uri) {
            @Override
            public void onMessage(String s) {
                super.onMessage(s);
                latch.countDown();
            }
        };
        client1.connect();
        client2.connect();

        // Submit first task
        executor.submit(() -> {
            JSONObject params = new JSONObject();
            params.put("name", "西瓜");
            params.put("index", 1);
            client1.send(params);
        });
        // Submit second task
        executor.submit(() -> {
            JSONObject params = new JSONObject();
            params.put("name", "苹果");
            params.put("index", 2);
            client2.send(params);
        });

        // Wait up to 2 minutes for both tasks to finish
        assertTrue(latch.await(2, TimeUnit.MINUTES));
        // Close clients and executor
        client1.close();
        client2.close();
        executor.shutdown();
    }
}
</code>

Code analysis:

Applicable scenario : Multi‑task collaboration testing, such as several users querying product prices concurrently.

Advantages : Precise control of task completion timing, supports timeout via

await

, avoiding indefinite waiting.

Considerations : Must invoke

countDown()

in each task to ensure correct logic.

Limitations : Manual counter maintenance can be error‑prone in complex logic.

shutdown + awaitTermination

The combination of

ExecutorService.shutdown()

and

awaitTermination()

is suitable for verifying that all tasks have completed without needing specific return values.

Example code testing batch WebSocket queries:

<code>package org.funtester.performance.books.chapter05.section7;

import org.funtester.performance.books.chapter05.section2.JavaWebSocketClient;
import org.junit.jupiter.api.Test;
import com.alibaba.fastjson.JSONObject;
import java.net.URI;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * FunTester uses shutdown() + awaitTermination() to test WebSocket client
 */
public class WebSocketShutdownTest {

    @Test
    public void testBatchWebSocketQueries() throws Exception {
        // Fixed thread pool of size 2
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // WebSocket server address
        URI uri = new URI("ws://localhost:12345/websocket/FunTester");
        // Create client
        JavaWebSocketClient client = new JavaWebSocketClient(uri);
        client.connect();

        // Send two different requests
        for (int i = 1; i <= 2; i++) {
            int index = i;
            executor.submit(() -> {
                JSONObject params = new JSONObject();
                params.put("name", index == 1 ? "西瓜" : "苹果");
                params.put("index", index);
                client.send(params);
            });
        }

        // Shut down executor and wait for all tasks to finish
        executor.shutdown();
        assertTrue(executor.awaitTermination(2, TimeUnit.MINUTES));
        client.close();
    }
}
</code>

Code analysis:

Applicable scenario : Verifying that all tasks finish, such as batch query requests.

Advantages : Simple to use, no extra synchronization tools required.

Considerations :

awaitTermination

must be called after

shutdown

with a reasonable timeout.

Limitations : Cannot directly obtain task results; suitable for state verification only.

Custom Runnable

A generic

FunTesterRunnable

class can simulate time‑consuming tasks for testing; replace it with actual query tasks in WebSocket tests.

<code>package org.funtester.performance.books.chapter05.section7;

public class FunTesterRunnable implements Runnable {
    private final long start, end;
    private long result;

    public FunTesterRunnable(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public void run() {
        result = 0;
        for (long i = start; i <= end; i++) {
            result += i;
        }
        System.out.println("FunTester: calculation completed, result: " + result);
    }

    public long getResult() {
        return result;
    }
}
</code>

Conclusion: When unit testing code based on

ExecutorService

, carefully design synchronization mechanisms to ensure reliable and deterministic tests. Avoid

Thread.sleep()

as it leads to instability and inefficiency; instead, use

CountDownLatch

,

Future

, or

shutdown/awaitTermination

for more efficient and robust concurrent testing.