Different Ways to Use Threads in Java

what are the different ways of thread usage In java?

In Java, threads can be utilized in various ways to achieve concurrent execution of tasks. Here are the primary methods for using threads in Java:

1. Extending the Thread Class

You can create a new thread by extending the Thread class and overriding its run() method. This is a straightforward way to define a thread's behavior.

class MyThread extends Thread {
    public void run() {
        // Code to be executed in the new thread
        System.out.println("Thread is running");
    }
}

// Usage
MyThread thread = new MyThread();
thread.start(); // Starts the thread

2. Implementing the Runnable Interface

Another common way to create a thread is by implementing the Runnable interface. This approach is more flexible than extending Thread, as it allows you to extend other classes as well.

class MyRunnable implements Runnable {
    public void run() {
        // Code to be executed in the new thread
        System.out.println("Runnable is running");
    }
}

// Usage
Thread thread = new Thread(new MyRunnable());
thread.start(); // Starts the thread

3. Using the Executor Framework

The Executor framework provides a higher-level abstraction for managing threads. It allows you to create a pool of threads and manage their execution more efficiently.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(new MyRunnable()); // Submit a task for execution
executor.shutdown(); // Shutdown the executor

4. Using Callable and Future

If you need to return a result from a thread or handle exceptions, you can use the Callable interface along with Future.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<String> {
    public String call() {
        return "Callable result";
    }
}

// Usage
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new MyCallable());
try {
    String result = future.get(); // Get the result
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
executor.shutdown();

5. Using ForkJoinPool

The ForkJoinPool is designed for parallel processing of tasks that can be broken down into smaller subtasks. It is particularly useful for divide-and-conquer algorithms.

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class MyTask extends RecursiveTask<Integer> {
    private final int n;

    MyTask(int n) {
        this.n = n;
    }

    @Override
    protected Integer compute() {
        if (n <= 1) {
            return n;
        }
        MyTask task1 = new MyTask(n - 1);
        task1.fork(); // Fork the task
        return n + task1.join(); // Join the result
    }
}

// Usage
ForkJoinPool pool = new ForkJoinPool();
MyTask task = new MyTask(10);
int result = pool.invoke(task);
System.out.println(result);

6. Using CompletableFuture

CompletableFuture is part of the java.util.concurrent package and provides a way to write asynchronous, non-blocking code.

import java.util.concurrent.CompletableFuture;

CompletableFuture.supplyAsync(() -> {
    // Code to run asynchronously
    return "Hello from CompletableFuture";
}).thenAccept(result -> {
    System.out.println(result);
});

7. Thread Pools

Thread pools manage a pool of worker threads, which can be reused for executing multiple tasks. This is more efficient than creating new threads for each task.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService pool = Executors.newCachedThreadPool();
pool.execute(() -> {
    // Task code
});
pool.shutdown();

Conclusion

Java provides multiple ways to work with threads, each suited for different scenarios. The choice of method depends on the specific requirements of your application, such as the need for returning results, handling exceptions, or managing a large number of concurrent tasks efficiently.