Multithreading

// Virtual Thread approach (Imperative, clean debugging):
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> {
        String user = fetchUserBlocking(); // Clean blocking call
        String order = fetchOrderBlocking();
        return user + " : " + order;
    });
}

// Flag fails if thread blocks in sleep:
// while(!flag) { Thread.sleep(10000); } // Won't wake up immediately!

// Interruption wakes up blocked sleep instantly:
Thread t = new Thread(() -> {
    try { Thread.sleep(10000); } catch (InterruptedException e) {
        System.out.println("Woke up immediately upon interrupt!");
    }
});
t.start();
t.interrupt();

Callable<String> callable = () -> "Computation Complete";
FutureTask<String> futureTask = new FutureTask<>(callable);

Thread t = new Thread(futureTask);
t.start();
System.out.println(futureTask.get()); // Blocks and prints result

// Contention-free random number generation in multi-threaded code:
int randomNum = ThreadLocalRandom.current().nextInt(1, 100);

Thread t = new Thread(() -> System.out.println("High priority task"));
t.setPriority(Thread.MAX_PRIORITY); // Hint to OS scheduler (not guaranteed!)
t.start();

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// Thread 1 and Thread 2 write to different bucket nodes concurrently without lock contention
map.put("Key1", 100);
map.put("Key2", 200);

Set<String> listeners = new CopyOnWriteArraySet<>();
listeners.add("ListenerA");
// Fast lock-free iteration over snapshot without ConcurrentModificationException
for (String l : listeners) System.out.println(l);

AtomicReference<String> ref = new AtomicReference<>("initial");
ref.compareAndSet("initial", "updated");

AtomicStampedReference<String> stampedRef = new AtomicStampedReference<>("initial", 1);
stampedRef.compareAndSet("initial", "updated", 1, 2);

class SimpleSpinLock {
    private final AtomicBoolean locked = new AtomicBoolean(false);
    public void lock() {
        while (!locked.compareAndSet(false, true)) {
            Thread.onSpinWait(); // CPU pause instruction hint
        }
    }
    public void unlock() { locked.set(false); }
}

ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 2, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>()) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t != null) System.err.println("Task failed with: " + t.getMessage());
    }
};

// Correct way to stop a thread:
class CleanTask implements Runnable {
    private volatile boolean keepRunning = true;
    public void stop() { keepRunning = false; }
    public void run() {
        while (keepRunning && !Thread.currentThread().isInterrupted()) {
            // Work
        }
    }
}

class Service {
    synchronized void methodA() {
        methodB(); // Reentrant: Same thread does not block on acquiring 'this' lock again
    }
    synchronized void methodB() {
        System.out.println("Reentered successfully");
    }
}

// 10,000 OS threads cause severe context-switch thrashing.
// 10,000 Virtual threads run with near-zero context-switching cost:
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) executor.submit(() -> Thread.sleep(100));
}

CompletableFuture<User> fetchUser = CompletableFuture.supplyAsync(() -> getUser(1));
CompletableFuture<Order> fetchOrder = CompletableFuture.supplyAsync(() -> getOrder(101));

// Parallel combine:
CompletableFuture<String> summary = fetchUser.thenCombine(fetchOrder, 
    (u, o) -> u.getName() + " bought " + o.getItem());

// Running compute tasks on common pool via parallel stream:
List<Integer> list = List.of(1, 2, 3, 4, 5);
list.parallelStream().map(n -> n * 2).forEach(System.out::println);
// Dedicated pool for blocking I/O:
ForkJoinPool customPool = new ForkJoinPool(8);

ConcurrentMap<String, List<String>> map = new ConcurrentHashMap<>();
// Thread-safe atomic lazy creation of nested collection:
map.computeIfAbsent("users", k -> new CopyOnWriteArrayList<>()).add("Alice");

// Unfair lock (higher throughput, default):
ReentrantLock unfairLock = new ReentrantLock();

// Fair lock (FIFO order guaranteed, lower throughput):
ReentrantLock fairLock = new ReentrantLock(true);

Thread t = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // Work loop checking status without clearing
    }
});
t.start();
t.interrupt(); // Sets interrupt flag

// High contention bottleneck:
// synchronized void update() { ... long running operations ... }

// Minimized contention using Atomic / CAS:
private final AtomicInteger counter = new AtomicInteger();
void update() { counter.incrementAndGet(); }

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
// Producer Thread
new Thread(() -> {
    try { queue.put("Message"); } catch (InterruptedException e) {}
}).start();
// Consumer Thread
new Thread(() -> {
    try { String msg = queue.take(); System.out.println(msg); } catch (InterruptedException e) {}
}).start();

// Guaranteeing atomic 64-bit read/write across all JVM architectures:
private volatile long timestamp;
// For atomic incrementation:
private final AtomicLong counter = new AtomicLong();

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] deadlockedIds = bean.findDeadlockedThreads();
if (deadlockedIds != null) {
    ThreadInfo[] infos = bean.getThreadInfo(deadlockedIds);
    for (ThreadInfo info : infos) System.err.println("Deadlocked: " + info.getThreadName());
}

// Direct handoff without buffering:
BlockingQueue<Runnable> directHandOff = new SynchronousQueue<>();
// Separate put/take lock queue for high throughput:
BlockingQueue<Runnable> linkedQueue = new LinkedBlockingQueue<>(500);

// Simplified custom Exclusive Lock using AQS helper Sync:
class Mutex {
    private static class Sync extends AbstractQueuedSynchronizer {
        protected boolean tryAcquire(int arg) { return compareAndSetState(0, 1); }
        protected boolean tryRelease(int arg) { setState(0); return true; }
    }
    private final Sync sync = new Sync();
    public void lock() { sync.acquire(1); }
    public void unlock() { sync.release(1); }
}

// LockSupport.park suspends until unpark(thread) is called
Thread worker = new Thread(() -> {
    System.out.println("Parking thread...");
    LockSupport.park(); // No synchronized block needed
    System.out.println("Unparked and resumed!");
});
worker.start();
LockSupport.unpark(worker); // Grants permit to resume

ReentrantLock lock = new ReentrantLock();
try {
    lock.lockInterruptibly(); // Can be cancelled if thread is interrupted while blocked
    try { doWork(); } finally { lock.unlock(); }
} catch (InterruptedException e) {
    System.err.println("Lock acquisition was interrupted");
}

Queue<String> queue = new ConcurrentLinkedQueue<>();
queue.offer("Task 1"); // Lock-free append
String task = queue.poll(); // Lock-free head extraction

// Lock-free CAS loop (system-wide progress guaranteed):
do {
    oldVal = atomic.get();
    newVal = oldVal + 1;
} while (!atomic.compareAndSet(oldVal, newVal));

Thread daemon = new Thread(() -> {
    while (true) { /* Background metrics collection */ }
});
daemon.setDaemon(true); // JVM will not wait for this thread on exit
daemon.start();

public class SafeSingleton {
    private static volatile SafeSingleton instance; // Must be volatile!
    public static SafeSingleton getInstance() {
        if (instance == null) {
            synchronized (SafeSingleton.class) {
                if (instance == null) instance = new SafeSingleton();
            }
        }
        return instance;
    }
}