Java Memory Model & happens-before

11. Practice Problems

Each problem has a Show Answer button with runnable Java code. Try the problem yourself first, then check.

1. Fix the broken stop-flag program: add volatile to make the worker thread stop correctly.
   নিচের broken stop-flag program ঠিক করুন — volatile যোগ করে worker thread সঠিকভাবে থামান।
   ✨ Show Answer (উত্তর দেখুন)

   Main.java

   class Main {
       static volatile boolean done = false;
   
       public static void main(String[] args) throws Exception {
           Thread worker = new Thread(() -> {
               int spins = 0;
               while (!done) spins++;
               System.out.println("stopped after " + spins + " spins");
           });
           worker.start();
           Thread.sleep(10);
           done = true;
           worker.join();
           System.out.println("main exiting");
       }
   }

   Run Copy

2. Explain in 3 sentences why volatile int count; count++ is still a race condition.
   তিন বাক্যে ব্যাখ্যা করুন — volatile int count; count++ কেন এখনও race condition।
   ✨ Show Answer (উত্তর দেখুন)

   Answer: count++ is a compound operation — read the current value, add 1, write the result back. volatile guarantees that the individual read and write each have happens-before edges, but it does not prevent two threads from both reading the same stale value, both incrementing it to the same new value, and both writing back — losing one increment. To fix this, use AtomicInteger.incrementAndGet(), which performs the entire read-modify-write atomically via a CAS instruction.

   count++ হলো তিনটি operation — read, add 1, write back। volatile শুধু read ও write-এ happens-before দেয়, কিন্তু দুটি thread একই পুরনো মান read করে একই নতুন মান write করতে পারে — একটি increment হারিয়ে যায়। সমাধান: AtomicInteger.incrementAndGet() — CAS দিয়ে পুরো read-modify-write atomic।

3. Implement a thread-safe counter using synchronized that two threads each increment 5000 times, then print the final count.
   synchronized দিয়ে একটি thread-safe counter তৈরি করুন। দুটি thread প্রতিটি ৫০০০ বার increment করবে এবং শেষ মান print করবে।
   ✨ Show Answer (উত্তর দেখুন)

   Main.java

   class SafeCounter {
       private int n = 0;
       synchronized void inc() { n++; }
       synchronized int  get() { return n; }
   }
   
   class Main {
       public static void main(String[] args) throws Exception {
           SafeCounter c = new SafeCounter();
           Thread t1 = new Thread(() -> { for(int i=0;i<5000;i++) c.inc(); });
           Thread t2 = new Thread(() -> { for(int i=0;i<5000;i++) c.inc(); });
           t1.start(); t2.start();
           t1.join();  t2.join();
           System.out.println("final = " + c.get()); // always 10000
       }
   }

   Run Copy

4. Write the correct Initialization-on-Demand Holder singleton for a DatabasePool class with a url field, then verify the same instance is returned from two threads.
   DatabasePool class-এর জন্য সঠিক IODH singleton লিখুন। দুটি thread থেকে একই instance ফেরত আসছে কিনা verify করুন।
   ✨ Show Answer (উত্তর দেখুন)

   Main.java

   class DatabasePool {
       final String url;
       private DatabasePool() { url = "jdbc:postgresql://db.abcltech.com/prod"; }
   
       private static class Holder {
           static final DatabasePool INSTANCE = new DatabasePool();
       }
   
       static DatabasePool get() { return Holder.INSTANCE; }
   }
   
   class Main {
       public static void main(String[] args) throws Exception {
           DatabasePool[] results = new DatabasePool[2];
           Thread t1 = new Thread(() -> results[0] = DatabasePool.get());
           Thread t2 = new Thread(() -> results[1] = DatabasePool.get());
           t1.start(); t2.start();
           t1.join();  t2.join();
           System.out.println("same instance: " + (results[0] == results[1]));
           System.out.println("url: " + results[0].url);
       }
   }

   Run Copy

5. In 3 sentences, explain why the IODH pattern does not need volatile or explicit synchronized, yet is still thread-safe.
   তিন বাক্যে বলুন — IODH pattern-এ volatile বা synchronized না থাকলেও এটি কেন thread-safe।
   ✨ Show Answer (উত্তর দেখুন)

   Answer: The JVM initializes a class exactly once, and the class-loading mechanism is inherently thread-safe — the JMM guarantees a happens-before between the static initializer completing and any subsequent read of a static field. The Holder class is not loaded until the first call to get(), giving lazy initialization for free. Because INSTANCE is a final static field set in the static initializer, its value is safely published to all threads without needing any additional synchronization.

   JVM একটি class মাত্র একবার initialize করে, এবং class-loading mechanism inherently thread-safe — JMM static initializer শেষ হওয়া এবং static field read-এর মধ্যে happens-before guarantee দেয়। Holder class প্রথম get() call-এ load হয়, তাই lazy initialization আপনাআপনি পাওয়া যায়। INSTANCE একটি final static field হওয়ায় সব thread-এ নিরাপদে publish হয় — আলাদা synchronization লাগে না।