Guide to Concurrency and Multithreading

Concurrency = Juggling multiple balls (dealing with multiple things at once) Parallelism = Having multiple people each juggle one ball (actually doing multiple things simultaneously)

Process (Web Browser)
├── Own entrance (memory space)
├── Own security system (isolation)
├── Own utilities (system resources)
└── Residents (threads)

Each house (process) has:

• Own memory space (isolated from neighbors)
• Own resources (files, network connections)
• House number (Process ID)
• At least one resident (main thread)

Thread (Browser Tab)
├── Own bedroom (stack)
├── Own thoughts (program counter)
├── Own notes (registers)
└── Shares common areas (heap memory)

People in same house (threads) share:

• Kitchen (heap memory)
• Living room (file handles)
• House resources

But each person has:

• Own bedroom (stack)
• Own thoughts (program counter)
• Own ID (Thread ID)

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

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

class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Task running: " + Thread.currentThread().getName());
    }
}

// Usage
Thread thread = new Thread(new MyTask());
thread.start(); // Launch the thread

Why Runnable is better: Java single inheritance limitation - you can implement multiple interfaces!

What are they? Background helper threads that die when main program ends.

Thread daemonThread = new Thread(() -> {
    while (true) {
        System.out.println("Cleaning up...");
        try { Thread.sleep(1000); } catch (InterruptedException e) { break; }
    }
});
daemonThread.setDaemon(true); // Make it a daemon
daemonThread.start();

// When main program ends, daemon thread automatically stops

Real Examples:

• Garbage collector
• Timer threads
• Monitoring threads

class BankAccount {
    private int balance = 1000;
    
    // DANGER: Not synchronized!
    public void withdraw(int amount) {
        if (balance >= amount) {          // Thread A checks: 1000 >= 500 ✓
                                         // Thread B checks: 1000 >= 700 ✓
            balance = balance - amount;   // Thread A: 1000 - 500 = 500
                                         // Thread B: 1000 - 700 = 300
        }
    }
}

// Result: Balance could be 500 OR 300, depending on timing!
// Expected: Should reject one withdrawal when balance < 700

class BankAccount {
    private int balance = 1000;
    
    // Only ONE thread can access this method at a time
    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            System.out.println("Withdrawing: " + amount);
            balance = balance - amount;
            System.out.println("New balance: " + balance);
        } else {
            System.out.println("Insufficient funds!");
        }
    }
    
    public synchronized int getBalance() {
        return balance; // Also synchronized for consistency
    }
}

Key Points:

• Locks the entire object for the method duration
• Other synchronized methods must wait
• Thread-safe but potentially slower

class BankAccount {
    private int balance = 1000;
    private String accountInfo = "John Doe";
    
    public void withdraw(int amount) {
        // Multiple threads can enter method
        
        System.out.println("Processing withdrawal request...");
        
        synchronized(this) {  // Only critical section is locked
            if (balance >= amount) {
                balance = balance - amount;
            }
        } // Lock released immediately
        
        System.out.println("Transaction logged");
    }
}

Advantages:

• Faster: Only locks critical sections
• More precise control
• Better concurrency

public class SmartBankAccount {
    private int balance = 1000;
    private String accountInfo = "John Doe";
    private List<String> transactionHistory = new ArrayList<>();
    
    // Separate locks for different resources
    private final Object balanceLock = new Object();
    private final Object infoLock = new Object();
    private final Object historyLock = new Object();
    
    public void withdraw(int amount) {
        synchronized(balanceLock) {  // Only locks balance operations
            if (balance >= amount) {
                balance -= amount;
            }
        }
    }
    
    public void updateInfo(String newInfo) {
        synchronized(infoLock) {  // Different lock for account info
            accountInfo = newInfo;
        }
    }
    
    public void addTransaction(String transaction) {
        synchronized(historyLock) {  // Another lock for history
            transactionHistory.add(transaction);
        }
    }
    
    // These three methods can run SIMULTANEOUSLY!
}

Performance Boost: Operations on different data can run in parallel!

class ReentrantExample {
    public synchronized void methodA() {
        System.out.println("In methodA");
        methodB(); // Can same thread call another synchronized method?
    }
    
    public synchronized void methodB() {
        System.out.println("In methodB");
        // YES! Same thread can acquire same lock multiple times
    }
}

Why it works: Java tracks lock ownership by thread, not just lock acquisition.

class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {           // Thread A gets lock1
            System.out.println("Thread A: Got lock1");
            
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            
            synchronized(lock2) {       // Thread A waits for lock2
                System.out.println("Thread A: Got lock2");
            }
        }
    }
    
    public void method2() {
        synchronized(lock2) {           // Thread B gets lock2
            System.out.println("Thread B: Got lock2");
            
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            
            synchronized(lock1) {       // Thread B waits for lock1
                System.out.println("Thread B: Got lock1");
            }
        }
    }
}

// Result: Both threads wait forever!

class DeadlockFixed {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {       // Always acquire lock1 first
            synchronized(lock2) {   // Then lock2
                System.out.println("Thread A: Both locks acquired");
            }
        }
    }
    
    public void method2() {
        synchronized(lock1) {       // Same order: lock1 first
            synchronized(lock2) {   // Then lock2
                System.out.println("Thread B: Both locks acquired");
            }
        }
    }
}

// Result: Sequential execution, no deadlock!

Golden Rule: Always acquire locks in the same order!

class StarvationExample {
    public synchronized void importantWork() {
        // High priority threads keep calling this
        System.out.println("High priority work");
    }
    
    public synchronized void backgroundWork() {
        // Low priority threads never get a chance
        System.out.println("Background work");
    }
}

Solutions:

• Use fair locks: ReentrantLock(true)
• Time-bounded waiting
• Priority scheduling algorithms

class LivelockExample {
    static class PoliteWorker {
        private String name;
        private boolean active;
        
        public PoliteWorker(String name) {
            this.name = name;
            this.active = true;
        }
        
        public void work(PoliteWorker colleague) {
            while (active) {
                if (colleague.active) {
                    System.out.println(name + ": After you, " + colleague.name);
                    active = false;  // I'll step back
                    
                    try { Thread.sleep(100); } catch (InterruptedException e) {}
                    
                    active = true;   // Let me try again
                }
            }
        }
    }
    
    // Both workers keep stepping aside for each other!
    // They're not blocked, but no work gets done
}

Solution: Add randomization or timeout to break the cycle.