AdvancedMultithreadingDemo .java

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class AdvancedMultithreadingDemo {

    // Shared resource
    static class BankAccount {
        private double balance = 1000.0;
        private final Lock lock = new ReentrantLock();

        public void deposit(double amount) {
            lock.lock();
            try {
                balance += amount;
                System.out.println(Thread.currentThread().getName() + " deposited " + amount + 
                                   " | Balance: " + balance);
            } finally {
                lock.unlock();
            }
        }

        public void withdraw(double amount) {
            lock.lock();
            try {
                if (balance >= amount) {
                    balance -= amount;
                    System.out.println(Thread.currentThread().getName() + " withdrew " + amount + 
                                       " | Balance: " + balance);
                } else {
                    System.out.println(Thread.currentThread().getName() + " tried to withdraw " + amount + 
                                       " | Insufficient balance!");
                }
            } finally {
                lock.unlock();
            }
        }

        public double getBalance() {
            return balance;
        }
    }

    public static void main(String[] args) throws Exception {
        BankAccount account = new BankAccount();
        ExecutorService executor = Executors.newFixedThreadPool(4);
        CountDownLatch latch = new CountDownLatch(4);

        // Callable tasks
        List<Callable<Void>> tasks = Arrays.asList(
            () -> { account.deposit(200); latch.countDown(); return null; },
            () -> { account.withdraw(100); latch.countDown(); return null; },
            () -> { account.deposit(300); latch.countDown(); return null; },
            () -> { account.withdraw(500); latch.countDown(); return null; }
        );

        // Submit tasks
        for (Callable<Void> task : tasks) {
            executor.submit(task);
        }

        // Wait for all tasks to finish
        latch.await();

        System.out.println("\nAll basic transactions completed.\n");

        // Demonstrate CompletableFuture for async operations
        CompletableFuture<Double> interestCalculation = CompletableFuture.supplyAsync(() -> {
            System.out.println("Calculating interest asynchronously...");
            try { Thread.sleep(1500); } catch (InterruptedException e) {}
            return account.getBalance() * 0.05;
        }).thenApply(interest -> {
            System.out.println("Interest calculated: " + interest);
            return interest;
        });

        double interest = interestCalculation.get();
        account.deposit(interest);

        // Demonstrate Future with Callable
        Future<Double> balanceFuture = executor.submit(() -> {
            Thread.sleep(1000);
            return account.getBalance();
        });

        System.out.println("\nFinal balance after interest: " + balanceFuture.get());

        executor.shutdown();
        System.out.println("\nExecutor shutdown gracefully.");
    }
}