Practice Questions — Multithreading Basics

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

public class ThreadSafeCounter {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Expected: 20000");
        System.out.println("Actual: " + counter.getCount());
    }
}

public class ParallelSum {
    public static void main(String[] args) throws InterruptedException {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] results = new int[2];
        int mid = data.length / 2;

        Thread t1 = new Thread(() -> {
            int sum = 0;
            for (int i = 0; i < mid; i++) sum += data[i];
            results[0] = sum;
            System.out.println("Thread-1 sum: " + sum);
        });

        Thread t2 = new Thread(() -> {
            int sum = 0;
            for (int i = mid; i < data.length; i++) sum += data[i];
            results[1] = sum;
            System.out.println("Thread-2 sum: " + sum);
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Total: " + (results[0] + results[1]));
    }
}

import java.util.LinkedList;

class BoundedBuffer {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private int capacity;

    public BoundedBuffer(int capacity) { this.capacity = capacity; }

    public synchronized void produce(int item) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait();
        }
        buffer.add(item);
        System.out.println("Produced: " + item);
        notifyAll();
    }

    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();
        }
        int item = buffer.removeFirst();
        System.out.println("Consumed: " + item);
        notifyAll();
        return item;
    }
}

public class ProducerConsumerBuffer {
    public static void main(String[] args) {
        BoundedBuffer buffer = new BoundedBuffer(5);

        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    buffer.produce(i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) { e.printStackTrace(); }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.consume();
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) { e.printStackTrace(); }
        });

        producer.start();
        consumer.start();
    }
}

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

public class TaskProcessor {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 8; i++) {
            int taskId = i;
            pool.submit(() -> {
                System.out.println("Task " + taskId + " on " + Thread.currentThread().getName());
                try { Thread.sleep(500); } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        pool.shutdown();
        pool.awaitTermination(30, TimeUnit.SECONDS);
        System.out.println("All tasks completed.");
    }
}

public class DeadlockFix {
    private static final Object LOCK_A = new Object();
    private static final Object LOCK_B = new Object();

    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== FIXED VERSION (consistent lock order) ===");
        // Both threads acquire LOCK_A first, then LOCK_B
        Thread t1 = new Thread(() -> {
            synchronized (LOCK_A) {
                System.out.println("T1: locked A");
                try { Thread.sleep(50); } catch (InterruptedException e) {}
                synchronized (LOCK_B) {
                    System.out.println("T1: locked B");
                }
            }
            System.out.println("T1: done");
        });

        Thread t2 = new Thread(() -> {
            synchronized (LOCK_A) { // Same order: A then B
                System.out.println("T2: locked A");
                try { Thread.sleep(50); } catch (InterruptedException e) {}
                synchronized (LOCK_B) {
                    System.out.println("T2: locked B");
                }
            }
            System.out.println("T2: done");
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("No deadlock!");
    }
}