Synchronization & Intrinsic Locks

package concurrency.synchronization;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * A synchronized block locking only the critical section with a private
 * lock object, plus a static synchronized method locking the Class object.
 */
public class FineGrainedAndClassLevelLocking {

    static class OrderProcessor {
        private int orderCount = 0;
        private double totalRevenue = 0.0;
        // Dedicated lock objects: unreachable from outside this class,
        // and independent of each other (lock striping).
        private final Object revenueLock = new Object();
        private final Map<String, Integer> inventory = new ConcurrentHashMap<>();
        private final List<String> paymentLog = new CopyOnWriteArrayList<>();

        void processOrder(double price) {
            // Everything outside the block can run fully concurrently.
            synchronized (revenueLock) {
                orderCount++;
                totalRevenue += price;
            }
        }

        int getOrderCount() {
            synchronized (revenueLock) { return orderCount; }
        }
    }

    static class IdGenerator {
        private static int nextId = 0;

        // Locks IdGenerator.class -- the single monitor shared by every
        // caller, regardless of which (or whether any) instance they used.
        public static synchronized int getNextId() {
            return nextId++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        OrderProcessor processor = new OrderProcessor();
        Thread[] workers = new Thread[10];
        for (int i = 0; i < 10; i++) {
            workers[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) processor.processOrder(9.99);
            });
            workers[i].start();
        }
        for (Thread t : workers) t.join();
        System.out.println("Orders processed: " + processor.getOrderCount());   // 1000, every run

        for (int i = 0; i < 5; i++) {
            System.out.println("Generated ID: " + IdGenerator.getNextId());
        }
    }
}

package concurrency.synchronization;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Reentrancy: methodA() calls methodB(), both synchronized on `this` --
 * no deadlock. Plus double-checked-locking Singleton, the one place
 * volatile and synchronized must work together.
 */
public class ReentrancyAndDoubleCheckedLocking {

    public synchronized void methodA() {
        System.out.println("methodA acquired the lock, calling methodB...");
        methodB();   // re-enters the SAME lock -- hold count goes to 2, not a deadlock
    }

    public synchronized void methodB() {
        System.out.println("methodB running on the same lock, hold count 2.");
    }

    static class Singleton {
        // volatile prevents another thread from observing a reference to
        // a half-constructed instance due to instruction reordering.
        private static volatile Singleton instance;

        public static Singleton getInstance() {
            if (instance == null) {                       // 1st check, no lock: fast path
                synchronized (Singleton.class) {
                    if (instance == null) {                // 2nd check, with lock: closes the race
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

    public static void main(String[] args) {
        new ReentrancyAndDoubleCheckedLocking().methodA();

        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println("Same instance: " + (s1 == s2));

        // AtomicInteger: lock-free alternative to synchronized for simple counters.
        AtomicInteger counter = new AtomicInteger(0);
        counter.incrementAndGet();
        System.out.println("Atomic counter: " + counter.get());
    }
}