concurrent.java

package com.springbootwebcsocket.demo;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

//@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) throws InterruptedException {
        CounterWithLockNoRaceCondition.main(null);
//        OptimisticLockingExample.main(null);
    }


}

class CounterWithLockNoRaceCondition {
    private static int counter = 0;
    private static final Semaphore lock = new Semaphore(50);

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100000];

        for (int i = 0; i < 100000; i++) {
            threads[i] = Thread.ofVirtual().start(() -> {
                try {
                    lock.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                try {
                    counter++;
                } finally {
                    lock.release();
                }
            });

        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Counter with lock (pessimistic locking): " + counter);
    }
}


class OptimisticLockingExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        int numThreads = 100000;
        Thread[] threads = new Thread[numThreads];

        for (int i = 0; i < numThreads; i++) {
            threads[i] = new Thread(() -> {
                int localCounter;

                do {
                    localCounter = counter.get(); // Get the current counter value

                    // Compare-and-swap operation
                } while (!counter.compareAndSet(localCounter, localCounter + 1));
            });

            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Counter value after optimistic locking: " + counter);
    }
}