How to Execute Tasks Non-Blockingly with Java Executors and CompletableFuture?

Non-Blocking Task Execution with Java Executors

When working with multiple queues of tasks, it's crucial to avoid blocking operations that can consume excessive stack space. This article explores how to utilize Java's java.util.concurrent package to submit tasks to an executor without blocking, leveraging callbacks for task completion notifications.

Callback Approach

Define a callback interface that accepts the desired result or completion status of the task. Implement a wrapper class that accepts both the task and the callback. When the task is complete, the wrapper invokes the callback.

CompletableFuture and Asynchronous Execution

Java 8 introduced CompletableFuture, which offers a more sophisticated mechanism for composing asynchronous and conditional pipelines. Create a CompletableFuture that executes the task in a thread pool. Then, attach a listener to the future that will be invoked upon task completion.

Example

The following code snippet demonstrates the use of CompletableFuture for non-blocking task execution:

import java.util.concurrent.CompletableFuture;

// Service class to perform the task
class ExampleService {
    public String work() {
        // Simulated work
        char[] str = new char[5];
        ThreadLocalRandom current = ThreadLocalRandom.current();
        for (int idx = 0; idx < str.length; ++idx)
            str[idx] = (char) ('A' + current.nextInt(26));
        String msg = new String(str);
        System.out.println("Generated message: " + msg);
        return msg;
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        ExampleService svc = new ExampleService();
        CompletableFuture<String> f = CompletableFuture.supplyAsync(svc::work);
        
        // Attach a listener to the future
        f.thenAccept(result -> System.out.println("Result: " + result));
        
        // Main method can continue execution without blocking
        System.out.println("Main method exiting");
    }
}

This code creates a CompletableFuture that executes the work() method asynchronously. The thenAccept() method attaches a listener that will be invoked when the CompletableFuture completes, allowing for non-blocking execution of the task.

The above is the detailed content of How to Execute Tasks Non-Blockingly with Java Executors and CompletableFuture?. For more information, please follow other related articles on the PHP Chinese website!