Concurrency In Java

ReentrantLock()
// Creates an instance of ReentrantLock.
 
ReentrantLock(boolean fair)
// Creates an instance of ReentrantLock with the given fairness policy

import java.util.concurrent.locks.ReentrantLock;
 
public static void main(String[] args) {
    try (ExecutorService executor = Executors.newFixedThreadPool(10)) { // This is called try-with-resources
        ReentrantLock lock = new ReentrantLock(true); // Fair lock
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                lock.lock(); // Acquire the lock
                try {
                    // Critical section
                    System.out.println("Thread " + Thread.currentThread().getName() + " is in the critical section");
                } finally {
                    lock.unlock(); // Release the lock
                }
            });
        }
    }
}

class SimpleProducerConsumer {
    private static final int MAX_CAPACITY = 1;
    private int buffer = -1;
    private boolean isEmpty = true;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
 
    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (!isEmpty) {
                notFull.await();
            }
            buffer = value;
            isEmpty = false;
            System.out.println("Produced: " + value);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
 
    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (isEmpty) {
                notEmpty.await();
            }
            int value = buffer;
            buffer = -1;
            isEmpty = true;
            System.out.println("Consumed: " + value);
            notFull.signal();
            return value;
        } finally {
            lock.unlock();
        }
    }
}

    private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); // Fair lock
private static final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
private static final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
private static final List<String> sharedData = new ArrayList<>();
 
public static void main(String[] args) {
    // Initialize shared data
    sharedData.add("Initial Data");
 
    // Executor service to manage threads
    ExecutorService executor = Executors.newFixedThreadPool(10);
 
    // Create and submit reader tasks
    for (int i = 0; i < 5; i++) {
        executor.submit(new WriterTask("New Data " + i));
        executor.submit(new ReaderTask());
    }
 
    executor.shutdown();
}
 
static class ReaderTask implements Runnable {
    @Override
    public void run() {
        readLock.lock(); // Acquire the read lock
        try {
            Thread.sleep(1000);
            System.out.println("Thread " + Thread.currentThread().getName() + " is reading: " + sharedData);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readLock.unlock(); // Release the read lock
        }
    }
}
 
static class WriterTask implements Runnable {
    private final String newData;
 
    public WriterTask(String newData) {
        this.newData = newData;
    }
 
    @Override
    public void run() {
        writeLock.lock(); // Acquire the write lock
        try {
            Thread.sleep(1000);
            System.out.println("Thread " + Thread.currentThread().getName() + " is writing: " + newData);
            sharedData.add(newData);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock(); // Release the write lock
        }
    }
}

public static void main(String[] args) {
    CountDownLatch countDownLatch = new CountDownLatch(8);
 
    for (int i = 0; i < 8; i++) {
        Thread.ofVirtual().name("Virtual Thread-" + i).start(() -> {
            System.out.println(Thread.currentThread().getName() + " is doing some work...");
            countDownLatch.countDown();
            System.out.println(Thread.currentThread().getName() + " finished work.");
        });
    }
 
    try {
        countDownLatch.await(); // Waiting :)
        System.out.println("countDownLatch is zero!!!");
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

public static void main(String[] args) {
    CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> {
        System.out.println("3 threads have reached the barrier...");
    });
 
    for (int i = 0; i < 9; i++) {
        Thread thread = new Thread(() -> {
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        });
        thread.start();
    }
}

public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(3);
 
    for (int i = 0; i < 9; i++) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread " + Thread.currentThread().getName() + " is trying to acquire the semaphore");
                semaphore.acquire();
                System.out.println("Thread " + Thread.currentThread().getName() + " acquired the semaphore");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        });
        thread.start();
    }
}

public static void main(String[] args) {
    Phaser phaser = new Phaser(3); // 3 parties
 
    for (int i = 0; i < 3; i++) {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " is starting phase 1");
            phaser.arriveAndAwaitAdvance(); // Wait for all parties to arrive at this phase
 
            System.out.println(Thread.currentThread().getName() + " is starting phase 2");
            phaser.arriveAndAwaitAdvance(); // Wait for all parties to arrive at this phase
        });
        thread.start();
    }
 
    phaser.arriveAndDeregister(); // Main thread deregisters from the phaser
}

import java.util.concurrent.atomic.AtomicInteger;
import java.math.random.Random;
 
public static void main(String[] args) {
    AtomicInteger atomicCounter = new AtomicInteger(0);
 
    try (ExecutorService executor = Executors.newFixedThreadPool(10)) {
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> atomicCounter.updateAndGet(operand -> operand + 3));
        }
    }
 
    System.out.println("Final value of atomicCounter: " + atomicCounter.get());
 
}

static class FizzBuzz {
    int value;
 
    public FizzBuzz(int value) {
        this.value = value;
    }
 
}
 
public static void main(String[] args) {
    AtomicReference<FizzBuzz> fizzBuzz = new AtomicReference<>(new FizzBuzz(0));
 
    try (ExecutorService executor = Executors.newFixedThreadPool(5)) {
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                fizzBuzz.updateAndGet(f -> {
                    int newValue = f.value + 3;
                    return new FizzBuzz(newValue);
                });
            });
        }
    }
 
    System.out.println("Final FizzBuzz Value: " + fizzBuzz.get().value);
}

List<String> names = List.of("Alice", "Bob", "Charlie", "David", "Eve");
 
names.parallelStream() // Now it's a parallel stream :)
		.filter(name -> name.length() > 3)
		.map(String::toUpperCase)
		.forEach(x -> {
			try {
				Thread.sleep(1000); // Simulate a long-running operation
				System.out.println(x);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		});