Java Asynchronous programming

Java supports asynchronous programming using several techniques, including callbacks, futures, and the CompletableFuture API. Asynchronous programming is a technique used to improve application responsiveness and scalability by allowing multiple tasks to be executed concurrently.

Callbacks:

Callbacks are a way to execute code asynchronously. In Java, callbacks are implemented using interfaces with a single method that is called when an operation completes. The method signature of the interface is defined by the application code, and it can be called by the asynchronous API when the operation completes.

         Using anonymous inner classes:

public interface Callback {
    void onCallback();
}

public class Example {
    public void doAsyncTask(Callback callback) {
        // perform asynchronous task here
        // then call the callback when task completes
        callback.onCallback();
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        example.doAsyncTask(new Callback() {
            @Override
            public void onCallback() {
                System.out.println("Async task completed!");
            }
        });
    }
}

         Using lambda expressions:

public interface Callback {
    void onCallback();
}

public class Example {
    public void doAsyncTask(Callback callback) {
        // perform asynchronous task here
        // then call the callback when task completes
        callback.onCallback();
    }
    
    public static void main(String[] args) {
        Example example = new Example();
        example.doAsyncTask(() -> System.out.println("Async task completed!"));
    }
}

In both examples, the Callback interface defines a single method onCallback() that is called when the asynchronous task completes. The Example class implements the doAsyncTask() method, which takes a Callback parameter and performs the asynchronous task. The main() method creates an instance of the Example class and passes a callback to the doAsyncTask() method. The callback is called when the task completes. The first example uses an anonymous inner class to define the callback implementation, while the second example uses a lambda expression.    

 

Future:

 Futures are objects that represent the result of an asynchronous operation. Futures allow the application to perform other tasks while waiting for the asynchronous operation to complete. In Java, the Future interface is used to represent a future result, and it provides methods to check whether the operation has completed and retrieve the result.

In Java, asynchronous programming can be achieved using the Future interface, which represents a result of an asynchronous computation. The Future interface provides a way to obtain a result of an asynchronous computation that may not be available yet.

Here's an example of how to use Future for asynchronous programming:

import java.util.concurrent.*;

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

    Future<Integer> future = executor.submit(new Callable<Integer>() {
      public Integer call() {
        // Perform a time-consuming task here
        return 42;
      }
    });

    // Do some other work here while the task is executing

    try {
      Integer result = future.get(); // This will block until the result is available
      System.out.println("Result: " + result);
    } catch (InterruptedException e) {
      // Handle the exception
    } catch (ExecutionException e) {
      // Handle the exception
    }

    executor.shutdown();
  }
}

In this example, a new ExecutorService is created using the Executors.newSingleThreadExecutor() method. This creates an executor that uses a single thread to execute tasks. A Callable object is then created and submitted to the executor using the submit method. The Callable object performs a time-consuming task and returns an Integer result.

The submit method returns a Future object that represents the result of the computation. The get method of the Future object is used to obtain the result of the computation. This method blocks until the result is available.

The ExecutorService is then shut down to release any resources it is using.

This is just a simple example, but Future can be used in more complex scenarios where multiple tasks are executed concurrently and their results are combined in some way.

CompletableFuture:

The CompletableFuture API was introduced in Java 8, and it provides a rich set of methods for performing asynchronous operations. The CompletableFuture API is built on top of the Future interface and provides support for chaining and combining multiple asynchronous operations.

 

CompletableFuture<String> futureResult = CompletableFuture.supplyAsync(() -> {
// some asynchronous computation
return "Result";
});

// Attach a callback to handle the result when it's complete
futureResult.thenAccept(result -> System.out.println(result));

// You can also chain multiple operations
CompletableFuture<Integer> lengthFuture = futureResult.thenApply(String::length);

// Handle errors
futureResult.exceptionally(ex -> {
System.err.println("Exception: " + ex.getMessage());
return null;
});

// Wait for the result (not recommended in production code)
futureResult.join();
 

To use asynchronous programming in Java, you can use the Executor framework, which provides a set of classes for managing thread pools and executing tasks asynchronously. The Executor framework is designed to simplify the process of creating and managing threads in Java, and it provides a high-level abstraction for asynchronous programming.