Techsperiments

Futures for Running Java Threads

—

by

zener
in ,

1. Introduction to Futures in Java

The Future interface in Java is a part of the java.util.concurrent package introduced in Java 5. It represents the result of an asynchronous computation. A Future acts as a placeholder for a result that may not be immediately available because the computation is still in progress.

Here’s how the Future interface works:

  • You submit a task to an ExecutorService.
  • The ExecutorService returns a Future object.
  • You can use the Future object to:
    • Check if the computation is complete.
    • Retrieve the result once available.
    • Cancel the computation if needed.

2. Key Benefits of Using Futures

  • Asynchronous Processing: Futures allow you to offload long-running tasks and retrieve results later.
  • Non-Blocking: The calling thread can continue executing other tasks while waiting for the result.
  • Thread Pool Management: Futures integrate seamlessly with Java’s Executor Framework, simplifying thread management.
  • Improved Scalability: Running tasks in parallel increases application throughput.

3. Java’s Executor Framework and Futures

The ExecutorService is the foundation for managing threads in Java. It provides methods to submit tasks and manage their execution. Futures come into play when tasks are submitted using the submit() method.

Here’s how you can use Futures with the Executor Framework:

package com.techsperiments.concurrency;

import java.util.concurrent.*;

public class FutureExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Callable<String> task = () -> {
            Thread.sleep(2000); // Simulate a long-running task
            return "Task completed";
        };

        Future<String> future = executorService.submit(task);

        try {
            System.out.println("Doing other work...");
            String result = future.get(); // Blocks until the task is complete
            System.out.println("Result from Future: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

Key Points:

  • ExecutorService: Manages threads.
  • Callable: Represents a task that returns a value.
  • Future: Acts as a handle to retrieve the task’s result.

4. Limitations of Basic Futures

While Future is a useful abstraction, it has some limitations:

  1. Blocking on Result: The get() method blocks the calling thread until the computation is complete.
  2. No Exception Handling: Futures don’t provide built-in mechanisms to handle exceptions asynchronously.
  3. No Chaining: Basic Futures don’t allow chaining of dependent tasks.
  4. No Notifications: There’s no way to get notified when the task is complete without polling.

5. Advanced Features with CompletableFuture

The introduction of CompletableFuture in Java 8 addressed many of these limitations. It allows you to:

  • Chain tasks together.
  • Handle exceptions seamlessly.
  • Combine multiple Futures.
  • Execute tasks asynchronously without blocking.

Let’s explore a few features of CompletableFuture.

Chaining Futures

package com.techsperiments.concurrency;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureChaining {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching user data...");
            return "User: John";
        }).thenApply(user -> {
            System.out.println("Processing data for " + user);
            return user + " processed";
        }).thenAccept(result -> System.out.println("Final result: " + result))
          .exceptionally(ex -> {
              System.out.println("Error: " + ex.getMessage());
              return null;
          });
    }
}

Explanation:

  • supplyAsync(): Asynchronously fetches user data.
  • thenApply(): Processes the data.
  • thenAccept(): Consumes the result.
  • exceptionally(): Handles any exceptions.

Combining Multiple Futures

package com.techsperiments.concurrency;

import java.util.concurrent.CompletableFuture;

public class CombineFutures {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Task 1 result");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Task 2 result");

        future1.thenCombine(future2, (result1, result2) -> result1 + " and " + result2)
               .thenAccept(System.out::println);
    }
}

6. Code Examples: A Practical Guide

Example 1: Simple Futures

package com.techsperiments.concurrency;

import java.util.concurrent.*;

public class SimpleFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<Integer> future = executor.submit(() -> {
            System.out.println("Calculating sum...");
            return 10 + 20;
        });

        System.out.println("Result: " + future.get());
        executor.shutdown();
    }
}

Example 2: Handling Multiple Futures with invokeAll

package com.techsperiments.concurrency;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class InvokeAllExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        List<Callable<String>> tasks = new ArrayList<>();
        tasks.add(() -> "Task 1 completed");
        tasks.add(() -> "Task 2 completed");
        tasks.add(() -> "Task 3 completed");

        List<Future<String>> futures = executor.invokeAll(tasks);

        for (Future<String> future : futures) {
            try {
                System.out.println(future.get());
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        executor.shutdown();
    }
}

Example 3: Asynchronous Workflows with CompletableFuture

package com.techsperiments.concurrency;

import java.util.concurrent.CompletableFuture;

public class AsyncWorkflow {
    public static void main(String[] args) {
        CompletableFuture<Void> workflow = CompletableFuture.supplyAsync(() -> "Fetching data")
                .thenApply(data -> {
                    System.out.println("Processing: " + data);
                    return data + " processed";
                }).thenAccept(result -> System.out.println("Final result: " + result));

        workflow.join(); // Wait for the workflow to complete
    }
}

7. Real-World Use Cases of Futures

  1. Web Service Calls:
    • Fetching data from APIs concurrently.
    • Aggregating results from multiple services.
  2. Batch Processing:
    • Processing large datasets in chunks.
    • Running computationally intensive tasks in parallel.
  3. Event-Driven Applications:
    • Non-blocking event handling.
    • Real-time data streaming.

8. Common Pitfalls and Best Practices

Pitfalls

  • Blocking on get(): Avoid blocking the main thread; use thenApply() or join() instead.
  • Overuse of Threads: Excessive use of threads can lead to resource exhaustion.
  • Uncaught Exceptions: Always handle exceptions explicitly.

Best Practices

  • Use CompletableFuture for more complex workflows.
  • Leverage ExecutorService with a properly configured thread pool.
  • Combine or chain tasks to simplify code and reduce boilerplate.
  • Monitor and tune thread pool sizes for optimal performance.

9. Conclusion

Futures and CompletableFuture provide robust mechanisms for asynchronous programming in Java. By integrating these features into your application, you can achieve higher efficiency and better scalability. Whether you’re working on simple asynchronous tasks or building complex workflows, mastering Futures is an essential skill for any Java developer.

Happy coding! 🚀

Bonus :

To demonstrate how threads can return class objects and collections in a thread-safe manner, we’ll expand on the earlier examples. We’ll also explore how to ensure thread safety when working with shared resources or returning collections.

Returning Class Objects from Threads

Often, threads need to return custom class objects after performing computations. This can be done using the Callable interface, as it allows us to return any type of result, including instances of user-defined classes.

Example: Returning a Class Object

package com.techsperiments.concurrency;

import java.util.concurrent.*;

public class ClassObjectFutureExample {

    // Custom class to be returned by the thread
    static class User {
        private final String name;
        private final int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{name='" + name + "', age=" + age + "}";
        }
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Callable<User> userTask = () -> {
            System.out.println("Creating user object...");
            return new User("John Doe", 30);
        };

        Future<User> future = executor.submit(userTask);

        try {
            User user = future.get(); // Wait for the result
            System.out.println("User created: " + user);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

Returning Collections from Threads in a Thread-Safe Manner

When returning collections, it’s crucial to ensure thread safety if the collection will be shared or modified concurrently by multiple threads. Java provides thread-safe collection wrappers like Collections.synchronizedList() or concurrent collections like ConcurrentHashMap.

Example: Returning a Thread-Safe Collection

package com.techsperiments.concurrency;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.*;

public class CollectionFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Task to create a thread-safe list
        Callable<List<String>> listTask = () -> {
            System.out.println("Creating list...");
            List<String> list = Collections.synchronizedList(new ArrayList<>());
            list.add("Task 1 result");
            list.add("Task 2 result");
            return list;
        };

        Future<List<String>> future = executor.submit(listTask);

        try {
            List<String> resultList = future.get(); // Wait for the result
            synchronized (resultList) { // Explicit synchronization for safe iteration
                for (String result : resultList) {
                    System.out.println("Result: " + result);
                }
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

Using CompletableFuture to Return Class Objects or Collections

CompletableFuture makes it easier to handle asynchronous workflows and can be used to return class objects or collections.

Example: Returning a Class Object with CompletableFuture

package com.techsperiments.concurrency;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureClassObjectExample {

    static class User {
        private final String name;
        private final String email;

        public User(String name, String email) {
            this.name = name;
            this.email = email;
        }

        @Override
        public String toString() {
            return "User{name='" + name + "', email='" + email + "'}";
        }
    }

    public static void main(String[] args) {
        CompletableFuture<User> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching user details...");
            return new User("Jane Doe", "jane.doe@example.com");
        });

        future.thenAccept(user -> System.out.println("User created: " + user));
        future.join(); // Wait for completion
    }
}

Example: Returning a Thread-Safe Collection with CompletableFuture

package com.techsperiments.concurrency;

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.CompletableFuture;

public class CompletableFutureCollectionExample {
    public static void main(String[] args) {
        CompletableFuture<List<String>> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Building a thread-safe list...");
            List<String> list = Collections.synchronizedList(new ArrayList<>());
            list.add("Result 1");
            list.add("Result 2");
            return list;
        });

        future.thenAccept(resultList -> {
            synchronized (resultList) { // Explicit synchronization for iteration
                for (String result : resultList) {
                    System.out.println("Result: " + result);
                }
            }
        });

        future.join(); // Wait for completion
    }
}

Thread Safety with Concurrent Collections

For applications requiring high concurrency, use concurrent collections like ConcurrentHashMap, CopyOnWriteArrayList, or ConcurrentLinkedQueue.

Example: Using ConcurrentHashMap

package com.techsperiments.concurrency;

import java.util.concurrent.*;

public class ConcurrentMapExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        Runnable task1 = () -> {
            System.out.println("Task 1 adding values...");
            map.put("Key1", 1);
            map.put("Key2", 2);
        };

        Runnable task2 = () -> {
            System.out.println("Task 2 adding values...");
            map.put("Key3", 3);
            map.put("Key4", 4);
        };

        executor.submit(task1);
        executor.submit(task2);

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

Best Practices for Thread-Safe Collections

  1. Use Concurrent Collections: Prefer ConcurrentHashMap, CopyOnWriteArrayList, or ConcurrentLinkedQueue for high-concurrency scenarios.
  2. Explicit Synchronization: When using synchronized collections like Collections.synchronizedList, synchronize during iteration.
  3. Immutable Collections: If the collection doesn’t need to be modified, return an immutable collection using Collections.unmodifiableList().

By combining these techniques with Future or CompletableFuture, you can effectively handle complex asynchronous workflows in Java, ensuring thread safety for class objects and collections.

Comments

One response to “Futures for Running Java Threads”

  1. Marcel Kłopotowski Avatar
    Marcel Kłopotowski

    Great post on the Futures in Java. It gave such a clear overview of how beneficial asynchronous processing can be when managing threads.

    I do have a question though. When dealing with blocking calls like the “get()” method, have you found any elegant workarounds to avoid blocking other threads, or is CompletableFuture usually the best way to go?

    For anyone looking to dive deeper into programming concepts like these,
    I found some really insightful articles about Python and AI here that might pique your interest.

    Thanks again for breaking down these complex ideas so well!

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *