Concurrent Collections

8. Practice Problems

1. Count word frequencies in a list from two threads using ConcurrentHashMap.merge.
   দুটি thread থেকে word frequency গুনতে ConcurrentHashMap.merge ব্যবহার করুন।
   Show Answer (উত্তর দেখুন)

   Main.java

   import java.util.*;
   import java.util.concurrent.*;
   class Main {
       public static void main(String[] args) throws Exception {
           ConcurrentHashMap<String, Integer> m = new ConcurrentHashMap<>();
           List<String> words = List.of("a","b","a","c","b","a");
           Runnable r = () -> words.forEach(w -> m.merge(w, 1, Integer::sum));
           Thread t1 = new Thread(r), t2 = new Thread(r);
           t1.start(); t2.start(); t1.join(); t2.join();
           System.out.println(m);
       }
   }

   Run Copy

2. Explain in 2 sentences when CopyOnWriteArrayList is a good fit.
   দুই বাক্যে বলুন — CopyOnWriteArrayList কখন ভালো।
   Show Answer (উত্তর দেখুন)

   Answer: It is ideal when reads vastly outnumber writes and iterations must never see mid-write state — event listener lists, rarely-updated configuration, observer registrations. The copy-per-write cost makes it a bad choice for any list that changes on every request.

   read >> write এবং iteration-এ mid-write state না দেখতে হলে উপযুক্ত — event listener, config, observer list। প্রতিটি request-এ পাল্টায় এমন list-এ খারাপ।

3. Implement a producer/consumer using LinkedBlockingQueue with 3 items.
   LinkedBlockingQueue দিয়ে ৩টি item-এর producer/consumer বানান।
   Show Answer (উত্তর দেখুন)

   Main.java

   import java.util.concurrent.*;
   class Main {
       public static void main(String[] args) throws Exception {
           BlockingQueue<String> q = new LinkedBlockingQueue<>();
           Thread p = new Thread(() -> {
               try {
                   q.put("rice"); q.put("oil"); q.put("salt"); q.put("STOP");
               } catch (InterruptedException e) {}
           });
           Thread c = new Thread(() -> {
               try {
                   while (true) {
                       String s = q.take();
                       if (s.equals("STOP")) break;
                       System.out.println("consumed " + s);
                   }
               } catch (InterruptedException e) {}
           });
           p.start(); c.start();
           p.join();  c.join();
       }
   }

   Run Copy

4. Cache a computed value per key with computeIfAbsent.
   computeIfAbsent দিয়ে key-ভিত্তিক cache বানান।
   Show Answer (উত্তর দেখুন)

   Main.java

   import java.util.concurrent.*;
   class Main {
       public static void main(String[] args) {
           ConcurrentHashMap<Integer, Long> cache = new ConcurrentHashMap<>();
           for (int i : new int[]{5, 10, 5, 10, 15}) {
               long v = cache.computeIfAbsent(i, k -> {
                   System.out.println("  computing " + k);
                   return (long) k * k;
               });
               System.out.println(i + " -> " + v);
           }
       }
   }

   Run Copy

5. In 3 sentences, say why Collections.synchronizedMap is a bottleneck compared to ConcurrentHashMap.
   তিন বাক্যে বলুন — Collections.synchronizedMap কেন ConcurrentHashMap-এর চেয়ে ধীর।
   Show Answer (উত্তর দেখুন)

   Answer: Collections.synchronizedMap wraps every operation — including pure reads — in a single lock on the whole map, so concurrent readers serialize one after another. ConcurrentHashMap partitions the data and uses fine-grained or lock-free updates per bucket, allowing many threads to operate in parallel without contention. On typical workloads the difference is an order of magnitude, and it grows with core count.

   Collections.synchronizedMap প্রতিটি operation (pure read সহ) পুরো map-এর single lock-এ চালায় — concurrent reader-রাও serial হয়ে যায়। ConcurrentHashMap ভেতরে partition + fine-grained/lock-free — অনেক thread parallel-এ কাজ করে। core বাড়ালে পার্থক্য আরো বাড়ে।