Java Concurrency and Multithreading

Understanding concurrency and multithreading is crucial for developing high-performance Java applications. Let’s explore the key concepts and best practices.

Creating and Managing Threads

There are two main ways to create threads in Java:

// Method 1: Extending Thread class
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

// Method 2: Implementing Runnable interface
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running");
    }
}

// Usage
MyThread thread1 = new MyThread();
thread1.start();

Thread thread2 = new Thread(new MyRunnable());
thread2.start();

Synchronization

Synchronization is essential for thread safety:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

ExecutorService

The ExecutorService provides a higher-level replacement for working with threads:

import java.util.concurrent.*;

ExecutorService executor = Executors.newFixedThreadPool(5);

Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Task completed";
});

try {
    String result = future.get(2, TimeUnit.SECONDS);
    System.out.println(result);
} catch (TimeoutException e) {
    future.cancel(true);
}

executor.shutdown();

Best Practices

1. Use higher-level concurrency utilities instead of raw threads
2. Minimize synchronization scope
3. Prefer immutable objects
4. Use thread pools via ExecutorService
5. Always properly handle thread interruption

Remember to always consider thread safety when working with shared resources!