Advanced Java

Why Concurrency?

Benefits:

• Better performance: Use multiple CPU cores
• Responsiveness: Keep UI or API responsive during long operations
• Resource utilization: Better use of system resources
• Scalability: Handle more requests simultaneously

Challenges:

• Race conditions
• Deadlocks
• Thread safety
• Complexity

Creating Threads

Method 1: Extending Thread class

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + getName());
    }
}

MyThread thread = new MyThread();
thread.start();

Method 2: Implementing Runnable (Preferred)

public class MyTask implements Runnable {
    public void run() {
        System.out.println("Task running");
    }
}

Thread thread = new Thread(new MyTask());
thread.start();

Method 3: Lambda (Modern)

Thread thread = new Thread(() -> {
    System.out.println("Lambda task running");
});
thread.start();

Thread Lifecycle

• NEW: Thread created but not started
• RUNNABLE: Thread executing or ready to execute
• BLOCKED: Waiting for monitor lock
• WAITING: Waiting indefinitely
• TIMED_WAITING: Waiting for specified time
• TERMINATED: Thread has completed

Thread Methods

Thread thread = new Thread(() -> {
    System.out.println("Working...");
    try {
        Thread.sleep(1000); // Sleep for 1 second
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

thread.start();           // Start the thread
thread.join();            // Wait for thread to complete
thread.interrupt();       // Interrupt the thread
thread.isAlive();         // Check if thread is running
thread.getName();         // Get thread name
thread.setName("Worker"); // Set thread name
Thread.currentThread();   // Get current thread

The Problem: Race Conditions

public class Counter {
    private int count = 0;
    
    public void increment() {
        count++; // NOT thread-safe! (read-modify-write)
    }
    
    public int getCount() {
        return count;
    }
}

// Multiple threads incrementing
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) counter.increment();
});
Thread t2 = new Thread(() -> {
    for (int i = 0; i < 1000; i++) counter.increment();
});
t1.start();
t2.start();
t1.join();
t2.join();

System.out.println(counter.getCount()); // Not 2000! Race condition!

Solution 1: Synchronized

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// Or synchronized block
public class Counter {
    private int count = 0;
    private final Object lock = new Object();
    
    public void increment() {
        synchronized(lock) {
            count++;
        }
    }
}

Note: synchronized has performance overhead

Solution 2: Atomic Classes

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

// Other atomic classes
AtomicLong atomicLong = new AtomicLong();
AtomicBoolean atomicBoolean = new AtomicBoolean();
AtomicReference atomicRef = new AtomicReference<>();

Atomic operations are lock-free and faster than synchronized!

Executor Framework

Better alternative to manually creating threads:

import java.util.concurrent.*;

// Create thread pool with 5 threads
ExecutorService executor = Executors.newFixedThreadPool(5);

// Submit tasks
executor.submit(() -> {
    System.out.println("Task 1 executing");
});

executor.submit(() -> {
    System.out.println("Task 2 executing");
});

// Shutdown executor
executor.shutdown();

// Wait for all tasks to complete
executor.awaitTermination(1, TimeUnit.MINUTES);

Types of Executors

// Fixed thread pool
ExecutorService fixed = Executors.newFixedThreadPool(10);

// Cached thread pool (creates threads as needed)
ExecutorService cached = Executors.newCachedThreadPool();

// Single thread executor
ExecutorService single = Executors.newSingleThreadExecutor();

// Scheduled executor (for delayed/periodic tasks)
ScheduledExecutorService scheduled = 
    Executors.newScheduledThreadPool(5);

scheduled.schedule(() -> {
    System.out.println("Execute after 5 seconds");
}, 5, TimeUnit.SECONDS);

scheduled.scheduleAtFixedRate(() -> {
    System.out.println("Execute every 10 seconds");
}, 0, 10, TimeUnit.SECONDS);

Callable and Future

Callable is like Runnable but can return a value:

import java.util.concurrent.*;

Callable task = () -> {
    Thread.sleep(2000);
    return 42;
};

ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(task);

System.out.println("Task submitted");

// Do other work while task executes

// Get result (blocks if not ready)
try {
    Integer result = future.get(); // Blocks until complete
    System.out.println("Result: " + result);
    
    // Or with timeout
    Integer result2 = future.get(3, TimeUnit.SECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    e.printStackTrace();
}

executor.shutdown();

CompletableFuture

Modern async programming in Java:

CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    // Runs in separate thread
    return "Hello";
});

future.thenApply(s -> s + " World")
      .thenAccept(System.out::println)
      .join();

// Combine multiple futures
CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "World");

CompletableFuture combined = future1.thenCombine(future2, 
    (s1, s2) -> s1 + " " + s2);

System.out.println(combined.join()); // Hello World

CompletableFuture - Advanced

// Chain async operations
CompletableFuture.supplyAsync(() -> getUserId())
    .thenApplyAsync(id -> fetchUser(id))
    .thenApplyAsync(user -> enrichUserData(user))
    .thenAccept(user -> saveUser(user))
    .exceptionally(ex -> {
        log.error("Error: " + ex.getMessage());
        return null;
    });

// Run multiple tasks and wait for all
CompletableFuture f1 = CompletableFuture.supplyAsync(() -> "Task1");
CompletableFuture f2 = CompletableFuture.supplyAsync(() -> "Task2");
CompletableFuture f3 = CompletableFuture.supplyAsync(() -> "Task3");

CompletableFuture allOf = CompletableFuture.allOf(f1, f2, f3);
allOf.join();

// Or wait for any to complete
CompletableFuture