Thread Libraries

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

import java.util.concurrent.*;
import java.util.List;
import java.util.ArrayList;
 
/**
 * Comprehensive Thread Creation Patterns in Java
 */
public class ThreadCreationPatterns {
    
    /**
     * Pattern 1: Thread Subclass
     * Best for: Simple cases where you need Thread methods directly
     */
    static class WorkerThread extends Thread {
        private final int workerId;
        
        public WorkerThread(int id) {
            super("Worker-" + id);  // Set thread name
            this.workerId = id;
        }
        
        @Override
        public void run() {
            System.out.println(getName() + " starting work");
            try {
                // Simulate work
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(getName() + " interrupted");
                Thread.currentThread().interrupt(); // Preserve interrupt status
                return;
            }
            System.out.println(getName() + " completed");
        }
    }
    
    /**
     * Pattern 2: Runnable Implementation
     * Best for: Tasks that need to extend another class, or be submitted to executors
     */
    static class DataProcessor implements Runnable {
        private final String data;
        private volatile boolean completed = false;  // Visibility!
        
        public DataProcessor(String data) {
            this.data = data;
        }
        
        @Override
        public void run() {
            System.out.println("Processing: " + data + 
                " on " + Thread.currentThread().getName());
            
            // Process data...
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
            
            completed = true;
        }
        
        public boolean isCompleted() {
            return completed;
        }
    }
    
    /**
     * Pattern 3: Callable with Future
     * Best for: Tasks that return results or throw exceptions
     */
    static class ComputeTask implements Callable<Long> {
        private final int n;
        
        public ComputeTask(int n) {
            this.n = n;
        }
        
        @Override
        public Long call() throws Exception {
            // Compute factorial (just an example)
            if (n < 0) {
                throw new IllegalArgumentException("n must be >= 0");
            }
            
            long result = 1;
            for (int i = 2; i <= n; i++) {
                result *= i;
                // Check for interruption in long computations
                if (Thread.currentThread().isInterrupted()) {
                    throw new InterruptedException("Computation cancelled");
                }
            }
            return result;
        }
    }
    
    /**
     * Pattern 4: Lambda/Method Reference (Java 8+)
     * Best for: Short tasks, inline definitions
     */
    public static void lambdaPatterns() {
        // Lambda implementing Runnable
        Thread t1 = new Thread(() -> {
            System.out.println("Lambda thread running");
        });
        t1.start();
        
        // Method reference
        Thread t2 = new Thread(ThreadCreationPatterns::doWork);
        t2.start();
        
        // With ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        // Submit Runnable lambda
        executor.submit(() -> System.out.println("Runnable task"));
        
        // Submit Callable lambda (note: returns value)
        Future<String> future = executor.submit(() -> {
            Thread.sleep(100);
            return "Callable result";
        });
        
        try {
            String result = future.get(1, TimeUnit.SECONDS);
            System.out.println("Got: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
    }
    
    private static void doWork() {
        System.out.println("Method reference thread running");
    }
    
    /**
     * Demonstration: Proper Thread Creation and Joining
     */
    public static void main(String[] args) throws Exception {
        // Create and start multiple threads
        List<Thread> threads = new ArrayList<>();
        
        for (int i = 0; i < 5; i++) {
            Thread t = new WorkerThread(i);
            threads.add(t);
            t.start();  // Starts the thread!
        }
        
        // Wait for all threads to complete
        for (Thread t : threads) {
            t.join();  // Blocks until t terminates
        }
        
        System.out.println("All workers completed");
        
        // Callable example with timeout
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<Long> future = executor.submit(new ComputeTask(20));
        
        try {
            Long result = future.get(5, TimeUnit.SECONDS);
            System.out.println("20! = " + result);
        } catch (TimeoutException e) {
            future.cancel(true);  // Interrupt the task
            System.out.println("Computation timed out");
        }
        
        executor.shutdown();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/**
 * Comprehensive Thread API Usage Examples
 */
public class ThreadAPIExample {
 
    /**
     * Proper interrupt handling pattern
     * This is the correct way to handle InterruptedException
     */
    static class InterruptibleWorker implements Runnable {
        @Override
        public void run() {
            System.out.println("Worker started");
            
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    // Do some work
                    doWork();
                    
                    // Sleep (interruptible operation)
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                // InterruptedException clears interrupt flag!
                // We must restore it for callers to see
                Thread.currentThread().interrupt();
                System.out.println("Worker interrupted during sleep");
            }
            
            System.out.println("Worker terminating gracefully");
        }
        
        private void doWork() {
            // CPU-bound work should periodically check interrupt flag
            for (int i = 0; i < 1000; i++) {
                if (Thread.currentThread().isInterrupted()) {
                    return;  // Exit early if interrupted
                }
                // ... computation ...
            }
        }
    }
    
    /**
     * Joining with timeout
     */
    public static void joinWithTimeout() throws InterruptedException {
        Thread worker = new Thread(() -> {
            try {
                Thread.sleep(5000);  // Simulate long work
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        
        worker.start();
        
        // Wait at most 2 seconds
        worker.join(2000);
        
        if (worker.isAlive()) {
            System.out.println("Worker still running, interrupting...");
            worker.interrupt();
            worker.join();  // Wait for it to actually finish
        }
        
        System.out.println("Worker state: " + worker.getState());
    }
    
    /**
     * Thread information and debugging
     */
    public static void threadInfo() {
        Thread current = Thread.currentThread();
        
        System.out.println("Thread Information:");
        System.out.println("  Name: " + current.getName());
        System.out.println("  ID: " + current.getId());
        System.out.println("  Priority: " + current.getPriority());
        System.out.println("  State: " + current.getState());
        System.out.println("  Is Daemon: " + current.isDaemon());
        System.out.println("  Is Alive: " + current.isAlive());
        System.out.println("  Thread Group: " + current.getThreadGroup().getName());
        
        // Stack trace
        System.out.println("  Stack trace:");
        for (StackTraceElement element : current.getStackTrace()) {
            System.out.println("    " + element);
        }
    }
    
    /**
     * Daemon threads example
     */
    public static void daemonThreadExample() {
        Thread daemon = new Thread(() -> {
            while (true) {
                System.out.println("Daemon running...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        
        // MUST set daemon BEFORE start()
        daemon.setDaemon(true);
        daemon.setName("BackgroundDaemon");
        daemon.start();
        
        // When main exits, daemon is killed abruptly
        System.out.println("Main thread exiting, daemon will be killed");
    }
    
    /**
     * All threads dump (for debugging)
     */
    public static void dumpAllThreads() {
        System.out.println("\n=== All Thread Stack Traces ===");
        Thread.getAllStackTraces().forEach((thread, stackTrace) -> {
            System.out.println("\n" + thread.getName() + 
                " (id=" + thread.getId() + 
                ", state=" + thread.getState() + "):");
            for (StackTraceElement element : stackTrace) {
                System.out.println("    " + element);
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

import java.util.ArrayList;
import java.util.List;
 
/**
 * Monitor Synchronization Patterns in Java
 */
public class SynchronizationPatterns {
 
    /**
     * Basic synchronized method pattern
     * Every method shares object's single lock
     */
    static class Counter {
        private int count = 0;
        
        public synchronized void increment() {
            count++;  // Atomic under lock
        }
        
        public synchronized int get() {
            return count;
        }
        
        // These two methods share the same lock!
        // Only one can execute at a time on same instance
    }
    
    /**
     * Synchronized block with minimal scope
     * Better performance: lock held for shorter duration
     */
    static class ImprovedCounter {
        private final Object lock = new Object();  // Private lock object
        private int count = 0;
        
        public void increment() {
            // Pre-computation outside lock
            int incrementBy = calculateIncrement();
            
            synchronized(lock) {  // Lock only what's needed
                count += incrementBy;
            }
            
            // Post-processing outside lock
            logIncrement();
        }
        
        private int calculateIncrement() { return 1; }
        private void logIncrement() { /* ... */ }
    }
    
    /**
     * Multiple lock objects for independent data
     * Increases concurrency by reducing contention
     */
    static class MultiLockExample {
        private final Object readLock = new Object();
        private final Object writeLock = new Object();
        
        private int readCount = 0;
        private int writeCount = 0;
        
        public void recordRead() {
            synchronized(readLock) {  // Doesn't block writers
                readCount++;
            }
        }
        
        public void recordWrite() {
            synchronized(writeLock) {  // Doesn't block readers
                writeCount++;
            }
        }
    }
    
    /**
     * wait()/notify() for thread coordination
     * Classic producer-consumer pattern
     */
    static class BoundedBuffer<T> {
        private final List<T> items = new ArrayList<>();
        private final int capacity;
        
        public BoundedBuffer(int capacity) {
            this.capacity = capacity;
        }
        
        public synchronized void put(T item) throws InterruptedException {
            // Wait while buffer is full
            while (items.size() == capacity) {
                wait();  // Releases lock, waits for notify
            }
            
            items.add(item);
            notifyAll();  // Wake waiting consumers
        }
        
        public synchronized T take() throws InterruptedException {
            // Wait while buffer is empty
            while (items.isEmpty()) {
                wait();  // Releases lock, waits for notify
            }
            
            T item = items.remove(0);
            notifyAll();  // Wake waiting producers
            return item;
        }
        
        public synchronized int size() {
            return items.size();
        }
    }
    
    /**
     * CRITICAL: Always use while loop with wait()!
     * Spurious wakeups can occur; condition may not be true
     */
    static class CorrectWaitPattern {
        private boolean conditionMet = false;
        
        public synchronized void waitForCondition() throws InterruptedException {
            // CORRECT: while loop
            while (!conditionMet) {
                wait();
            }
            // Condition is definitely true here
            
            /*
             * WRONG:
             * if (!conditionMet) { wait(); }
             * 
             * After spurious wakeup, condition might still be false!
             */
        }
        
        public synchronized void signalCondition() {
            conditionMet = true;
            notifyAll();  // Prefer notifyAll unless specific reason
        }
    }
    
    /**
     * Static synchronized method locks the Class object
     */
    static class StaticSyncExample {
        private static int sharedCounter = 0;
        
        // Locks StaticSyncExample.class
        public static synchronized void incrementStatic() {
            sharedCounter++;
        }
        
        // Equivalent:
        public static void incrementStaticEquivalent() {
            synchronized(StaticSyncExample.class) {
                sharedCounter++;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/**
 * Java Memory Model: Visibility and Ordering
 */
public class JavaMemoryModel {
 
    /**
     * BROKEN: No visibility guarantee
     * Thread 2 may never see ready=true, even if Thread 1 sets it
     */
    static class BrokenVisibility {
        private boolean ready = false;
        private int number = 0;
        
        public void writer() {
            number = 42;
            ready = true;  // May be reordered before number=42!
        }
        
        public void reader() {
            while (!ready) {
                // May loop forever! CPU may cache ready=false
                Thread.yield();
            }
            // May print 0 even if we see ready=true (due to reordering)!
            System.out.println(number);
        }
    }
    
    /**
     * FIXED with volatile: Full visibility
     * volatile prevents reordering and ensures visibility
     */
    static class VolatileVisibility {
        private volatile boolean ready = false;
        private int number = 0;
        
        public void writer() {
            number = 42;
            ready = true;  // Volatile write: cannot be reordered
                           // Also flushes all preceding writes
        }
        
        public void reader() {
            while (!ready) {
                Thread.yield();
            }
            // Guaranteed to see 42
            // Volatile read creates happens-before with volatile write
            System.out.println(number);  // Always prints 42
        }
    }
    
    /**
     * FIXED with synchronization: Mutual exclusion + visibility
     */
    static class SynchronizedVisibility {
        private boolean ready = false;
        private int number = 0;
        private final Object lock = new Object();
        
        public void writer() {
            synchronized(lock) {
                number = 42;
                ready = true;
            }  // Lock release flushes writes
        }
        
        public void reader() {
            synchronized(lock) {  // Lock acquire reads fresh values
                while (!ready) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                System.out.println(number);  // Sees 42
            }
        }
    }
    
    /**
     * Double-Checked Locking: The classic JMM pitfall
     */
    static class Singleton {
        // MUST be volatile for safe double-checked locking!
        private static volatile Singleton instance;
        
        public static Singleton getInstance() {
            if (instance == null) {  // First check (no lock)
                synchronized(Singleton.class) {
                    if (instance == null) {  // Second check (with lock)
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
        
        /*
         * Without volatile, this is BROKEN!
         * 
         * Why? The constructor and assignment can be reordered:
         * 1. Allocate memory
         * 2. Assign reference to instance  <- Other thread sees non-null!
         * 3. Call constructor              <- But object isn't initialized!
         * 
         * With volatile, step 2 cannot happen before step 3.
         */
    }
    
    /**
     * Safe publication idioms
     */
    static class SafePublication {
        // 1. Static initializer (JVM guarantees safety)
        private static final Object STATIC_INIT = createObject();
        
        // 2. Volatile field
        private volatile Object volatileField;
        
        // 3. Final field (if object is effectively immutable)
        private final Object finalField;
        
        // 4. Guarded by lock
        private Object guardedField;
        private final Object lock = new Object();
        
        public SafePublication() {
            this.finalField = createObject();
        }
        
        public void publishSafely(Object obj) {
            // Option 1: volatile
            this.volatileField = obj;
            
            // Option 2: synchronized
            synchronized(lock) {
                this.guardedField = obj;
            }
        }
        
        private static Object createObject() {
            return new Object();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
 
/**
 * Modern Java Concurrency Utilities (java.util.concurrent)
 */
public class ModernConcurrency {
 
    /**
     * ReentrantLock: More flexible than synchronized
     * - Interruptible lock acquisition
     * - Timeout-based acquisition  
     * - Non-block try-lock
     * - Condition variables
     */
    static class ReentrantLockExample {
        private final ReentrantLock lock = new ReentrantLock();
        private int value;
        
        public void update(int delta) throws InterruptedException {
            // Can be interrupted while waiting for lock
            lock.lockInterruptibly();
            try {
                value += delta;
            } finally {
                lock.unlock();  // Always in finally!
            }
        }
        
        public boolean tryUpdate(int delta, long timeout, TimeUnit unit) 
                throws InterruptedException {
            // Timeout-based lock acquisition
            if (lock.tryLock(timeout, unit)) {
                try {
                    value += delta;
                    return true;
                } finally {
                    lock.unlock();
                }
            }
            return false;  // Couldn't get lock in time
        }
    }
    
    /**
     * ReadWriteLock: Multiple readers OR single writer
     */
    static class CachedData {
        private final ReadWriteLock lock = new ReentrantReadWriteLock();
        private Object cachedValue;
        private volatile boolean valid = false;
        
        public Object read() {
            lock.readLock().lock();  // Multiple readers allowed
            try {
                if (valid) {
                    return cachedValue;
                }
            } finally {
                lock.readLock().unlock();
            }
            
            // Must refresh - need write lock
            lock.writeLock().lock();  // Exclusive access
            try {
                if (!valid) {  // Double-check
                    cachedValue = loadValueFromDatabase();
                    valid = true;
                }
                return cachedValue;
            } finally {
                lock.writeLock().unlock();
            }
        }
        
        private Object loadValueFromDatabase() {
            return new Object();  // Simulated
        }
    }
    
    /**
     * Atomic Variables: Lock-free thread safety
     */
    static class AtomicExample {
        private final AtomicInteger counter = new AtomicInteger(0);
        private final AtomicReference<String> lastValue = new AtomicReference<>();
        
        public void incrementAndGet() {
            // Atomic read-modify-write
            int newValue = counter.incrementAndGet();
            System.out.println("Counter: " + newValue);
        }
        
        public void compareAndSet(String expected, String update) {
            // CAS operation - foundation of lock-free programming
            boolean success = lastValue.compareAndSet(expected, update);
            if (!success) {
                System.out.println("CAS failed, value was changed");
            }
        }
        
        public void atomicUpdate() {
            // updateAndGet with lambda (Java 8+)
            int result = counter.updateAndGet(current -> current * 2);
            System.out.println("Doubled to: " + result);
        }
    }
    
    /**
     * CountDownLatch: Wait for N events
     */
    static class LatchExample {
        public void waitForAll() throws InterruptedException {
            int numWorkers = 5;
            CountDownLatch latch = new CountDownLatch(numWorkers);
            
            for (int i = 0; i < numWorkers; i++) {
                final int id = i;
                new Thread(() -> {
                    System.out.println("Worker " + id + " starting");
                    // Do work...
                    latch.countDown();  // Signal completion
                }).start();
            }
            
            System.out.println("Main waiting for workers...");
            latch.await();  // Block until count reaches 0
            System.out.println("All workers complete!");
        }
    }
    
    /**
     * CompletableFuture: Composable async operations (Java 8+)
     */
    static class CompletableFutureExample {
        private final ExecutorService executor = Executors.newFixedThreadPool(4);
        
        public void asyncPipeline() {
            CompletableFuture.supplyAsync(() -> fetchData(), executor)
                .thenApply(data -> processData(data))
                .thenApply(result -> formatResult(result))
                .thenAccept(output -> System.out.println("Result: " + output))
                .exceptionally(e -> {
                    System.err.println("Error: " + e.getMessage());
                    return null;
                });
        }
        
        public void combineResults() {
            CompletableFuture<String> future1 = CompletableFuture.supplyAsync(
                () -> "Hello", executor
            );
            CompletableFuture<String> future2 = CompletableFuture.supplyAsync(
                () -> "World", executor
            );
            
            // Combine two futures
            future1.thenCombine(future2, (a, b) -> a + " " + b)
                   .thenAccept(System.out::println);  // "Hello World"
            
            // Wait for all futures
            CompletableFuture.allOf(future1, future2)
                             .thenRun(() -> System.out.println("All done"));
        }
        
        private String fetchData() { return "data"; }
        private String processData(String d) { return d.toUpperCase(); }
        private String formatResult(String r) { return "[" + r + "]"; }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

import java.util.*;
import java.util.concurrent.*;
 
/**
 * Thread Safety Design Patterns
 */
public class ThreadSafetyPatterns {
 
    /**
     * Pattern 1: Immutable Objects
     * Absolutely thread-safe - no synchronization needed
     */
    public static final class ImmutablePoint {
        private final int x;
        private final int y;
        
        public ImmutablePoint(int x, int y) {
            this.x = x;
            this.y = y;
        }
        
        public int getX() { return x; }
        public int getY() { return y; }
        
        // Return new object for "modifications"
        public ImmutablePoint translate(int dx, int dy) {
            return new ImmutablePoint(x + dx, y + dy);
        }
    }
    
    /**
     * Pattern 2: Thread Confinement with ThreadLocal
     * Each thread has its own instance
     */
    public static class UserContext {
        private static final ThreadLocal<UserContext> context = 
            ThreadLocal.withInitial(UserContext::new);
        
        private String userId;
        private String sessionId;
        
        public static UserContext get() {
            return context.get();
        }
        
        public static void clear() {
            context.remove();  // Important for thread pools!
        }
        
        public void setUserId(String id) { this.userId = id; }
        public String getUserId() { return userId; }
    }
    
    /**
     * Pattern 3: Monitor Pattern (Guarded State)
     * All state guarded by single lock
     */
    public static class MonitorVehicleTracker {
        // @GuardedBy("this")
        private final Map<String, MutablePoint> locations = new HashMap<>();
        
        public MonitorVehicleTracker() {
            // Initialize locations
        }
        
        public synchronized MutablePoint getLocation(String id) {
            MutablePoint loc = locations.get(id);
            return loc == null ? null : new MutablePoint(loc);  // Defensive copy!
        }
        
        public synchronized void setLocation(String id, int x, int y) {
            MutablePoint loc = locations.get(id);
            if (loc != null) {
                loc.x = x;
                loc.y = y;
            }
        }
        
        public synchronized Map<String, MutablePoint> getLocations() {
            // Must return deep copy
            Map<String, MutablePoint> result = new HashMap<>();
            for (Map.Entry<String, MutablePoint> entry : locations.entrySet()) {
                result.put(entry.getKey(), new MutablePoint(entry.getValue()));
            }
            return result;
        }
    }
    
    static class MutablePoint {
        public int x, y;
        public MutablePoint(int x, int y) { this.x = x; this.y = y; }
        public MutablePoint(MutablePoint p) { this.x = p.x; this.y = p.y; }
    }
    
    /**
     * Pattern 4: Safe Publication with volatile
     */
    public static class SafePublisher {
        private volatile Config config;
        
        public void updateConfig(Config newConfig) {
            // Volatile write publishes the object safely
            this.config = newConfig;
        }
        
        public Config getConfig() {
            // Volatile read sees fully constructed object
            return config;
        }
    }
    
    static class Config {
        private final String setting1;
        private final int setting2;
        public Config(String s1, int s2) { setting1 = s1; setting2 = s2; }
    }
    
    /**
     * Pattern 5: Delegating Thread Safety
     * Use thread-safe components
     */
    public static class DelegatingVehicleTracker {
        // ConcurrentHashMap is thread-safe
        private final ConcurrentMap<String, ImmutablePoint> locations;
        
        public DelegatingVehicleTracker(Map<String, ImmutablePoint> points) {
            this.locations = new ConcurrentHashMap<>(points);
        }
        
        public ImmutablePoint getLocation(String id) {
            return locations.get(id);  // Safe, returns immutable
        }
        
        public void setLocation(String id, int x, int y) {
            locations.put(id, new ImmutablePoint(x, y));
        }
        
        public Map<String, ImmutablePoint> getLocations() {
            // Unmodifiable view of thread-safe map
            return Collections.unmodifiableMap(
                new HashMap<>(locations)  // Snapshot
            );
        }
    }
    
    /**
     * Pattern 6: Copy-on-Write
     * For read-heavy workloads
     */
    public static class CopyOnWriteRegistry {
        private volatile List<Listener> listeners = new ArrayList<>();
        
        public void addListener(Listener l) {
            synchronized (this) {
                List<Listener> newList = new ArrayList<>(listeners);
                newList.add(l);
                listeners = newList;  // Volatile write publishes
            }
        }
        
        public void notifyListeners(String event) {
            // No synchronization for reads (very fast)
            for (Listener l : listeners) {  // Volatile read
                l.onEvent(event);
            }
        }
    }
    
    interface Listener {
        void onEvent(String event);
    }
}