java.util.concurrent

---

1. Creating and Using a Thread Pool

ExecutorService executorService = Executors.newFixedThreadPool(4);
executorService.submit(() -> {
    // Perform task
});

2. Executing Tasks Asynchronously

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Perform task
    return 10;
});
future.thenAccept(System.out::println);

3. Scheduling Tasks with ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(1);
scheduler.schedule(() -> {
    // Perform task
}, 5, TimeUnit.SECONDS);

4. Using a CountDownLatch to Wait for Multiple Tasks

CountDownLatch latch = new CountDownLatch(4);
ExecutorService executorService = Executors.newFixedThreadPool(4);

for (int i = 0; i < 4; i++) {
    executorService.submit(() -> {
        // Perform task
        latch.countDown();
    });
}

latch.await();

5. Using a Semaphore to Limit Concurrent Access

Semaphore semaphore = new Semaphore(3);

for (int i = 0; i < 10; i++) {
    executorService.submit(() -> {
        semaphore.acquire();
        // Perform task
        semaphore.release();
    });
}

6. Using a Phaser to Synchronize Threads

Phaser phaser = new Phaser(5);

for (int i = 0; i < 5; i++) {
    executorService.submit(() -> {
        // Perform task
        phaser.arriveAndAwaitAdvance();
    });
}

7. Using BlockingQueue to Communicate Between Threads

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

producerThread = new Thread(() -> {
    while (true) {
        // Produce data
        queue.put(data);
    }
});

consumerThread = new Thread(() -> {
    while (true) {
        // Consume data
        data = queue.take();
    }
});

8. Using CopyOnWriteArrayList for Concurrent Modification

List<Integer> list = new CopyOnWriteArrayList<>();

list.add(10);
list.add(20);

9. Using ConcurrentHashMap for Concurrent Access to Maps

Map<String, Integer> map = new ConcurrentHashMap<>();

map.put("key", 10);
map.get("key");

10. Using AtomicInteger for Concurrent Incrementation

AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();
counter.get();

11. Using AtomicReference for Concurrent Modification of Reference

AtomicReference<String> reference = new AtomicReference<>("initial");

reference.set("updated");
reference.get();

12. Using Executors.newCachedThreadPool()

ExecutorService executorService = Executors.newCachedThreadPool();
executorService.submit(() -> {
    // Perform task
});

13. Using Executors.newSingleThreadExecutor()

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(() -> {
    // Perform task
});

14. Using CompletableFuture.allOf()

CompletableFuture.allOf(future1, future2).thenAccept(() -> {
    // Both tasks completed
});

15. Using CompletableFuture.anyOf()

CompletableFuture.anyOf(future1, future2).thenAccept(result -> {
    // Any of the tasks completed
});

16. Using Executors.newWorkStealingPool()

ExecutorService executorService = Executors.newWorkStealingPool();
executorService.submit(() -> {
    // Perform task
});

17. Using Executors.newScheduledThreadPool()

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);
executorService.schedule(() -> {
    // Perform task
}, 5, TimeUnit.SECONDS);

18. Using Executors.newFixedThreadPool() with a Queue

ExecutorService executorService = Executors.newFixedThreadPool(4, new ArrayBlockingQueue<>(100));
executorService.submit(() -> {
    // Perform task
});

19. Using Executors.newScheduledThreadPool() with a Fixed Delay

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);
executorService.scheduleWithFixedDelay(() -> {
    // Perform task
}, 0, 5, TimeUnit.SECONDS);

20. Using Executors.newSingleThreadScheduledExecutor()

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.schedule(() -> {
    // Perform task
}, 5, TimeUnit.SECONDS);

21. Using CompletableFuture.thenAcceptBoth()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // Return "Hello"
});

future1.thenAcceptBoth(future2, (result1, result2) -> {
    // Handle both results
});

22. Using CompletableFuture.thenCombine()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // Return "Hello"
});

future1.thenCombine(future2, (result1, result2) -> {
    // Combine both results
}).thenAccept(System.out::println);

23. Using CompletableFuture.thenCompose()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

future1.thenCompose(result -> CompletableFuture.supplyAsync(() -> result * 2))
        .thenAccept(System.out::println);

24. Using CompletableFuture.handle()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

future1.handle((result, exception) -> {
    if (exception != null) {
        // Handle exception
    }
    return result;
});

25. Using CompletableFuture.exceptionally()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

future1.exceptionally(exception -> {
    // Handle exception
    return null;
});

26. Using CompletableFuture.applyToEither()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // Return "Hello"
});

future1.applyToEither(future2, result -> result == null ? "Default" : result);

27. Using CompletableFuture.acceptEither()

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // Return "Hello"
});

future1.acceptEither(future2, result -> {
    // Handle result
});

28. Using Synchronous Blocking Queues

BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

queue.put(10);
Integer result = queue.take();

29. Using LinkedBlockingDeque

LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>();

deque.put(10);
Integer result = deque.take();

30. Using PriorityQueue

PriorityQueue<Integer> pq = new PriorityQueue<>();

pq.add(10);
Integer result = pq.poll();

31. Using SynchronousQueue

BlockingQueue<Integer> queue = new SynchronousQueue<>();

queue.put(10);
Integer result = queue.take();

32. Using ReentrantLock

ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // Perform task
} finally {
    lock.unlock();
}

33. Using Condition

Condition condition = lock.newCondition();

lock.lock();
try {
    condition.await();
} catch (InterruptedException e) {
    // Handle interruption
} finally {
    lock.unlock();
}

34. Using Semaphore with Fairness

Semaphore semaphore = new Semaphore(3, true);

semaphore.acquire();
try {
    // Perform task
} finally {
    semaphore.release();
}

35. Using CountdownLatch with Timeouts

CountDownLatch latch = new CountDownLatch(4);

latch.await(5, TimeUnit.SECONDS);

36. Using Phaser with Multiple Phases

Phaser phaser = new Phaser(5);

phaser.register();

for (int i = 0; i < 5; i++) {
    phaser.arriveAndDeregister();
}

37. Using StampedLock for Optimistic Concurrency

StampedLock lock = new StampedLock();

long stamp = lock.tryOptimisticRead();

try {
    // Perform optimistic read
} finally {
    if (!lock.validate(stamp)) {
        lock.readLock();
        try {
            // Perform read
        } finally {
            lock.unlockRead(stamp);
        }
    }
}

38. Using CyclicBarrier for Waiting on Multiple Threads

CyclicBarrier barrier = new CyclicBarrier(4);

for (int i = 0; i < 4; i++) {
    barrier.await();
}

39. Using ThreadLocal for Thread-Local Storage

ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

threadLocal.set(10);
Integer result = threadLocal.get();

40. Using Executors.newWorkStealingPool(boolean)

ExecutorService executorService = Executors.newWorkStealingPool(true);

executorService.submit(() -> {
    // Perform task
});

41. Using Executors.newSingleThreadExecutor(ThreadFactory)

ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("Single-Thread-Executor");
        return thread;
    }
});

executorService.submit(() -> {
    // Perform task
});

42. Using CompletableFuture.completeExceptionally()

CompletableFuture<Integer> future = new CompletableFuture<>();

future.completeExceptionally(new RuntimeException());

43. Using CompletableFuture.thenRun()

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

future.thenRun(() -> {
    // Handle completion
});

44. Using CompletableFuture.orTimeout()

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Return 10
});

future.orTimeout(5, TimeUnit.SECONDS);

45. Using SynchronousQueue with Consumers

SynchronousQueue<Integer> queue = new SynchronousQueue<>();

queue.put(10);

Consumer<Integer> consumer = value -> {
    // Consume value
};

queue.take(consumer);

46. Using LinkedBlockingQueue with Iterators

LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

queue.put(10);

Iterator<Integer> iterator = queue.iterator();

while (iterator.hasNext()) {
    Integer value = iterator.next();
    // Process value
}

47. Using PriorityQueue with Comparators

PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1; // Reverse order
    }
});

pq.add(10);
Integer result = pq.poll();

48. Using SynchronousQueue with Timeouts

SynchronousQueue<Integer> queue = new SynchronousQueue<>();

try {
    Integer result = queue.poll(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
    // Handle interruption
}

49. Using ForkJoinPool

ForkJoinPool forkJoinPool = new ForkJoinPool(4);

RecursiveAction task = new RecursiveAction() {
    @Override
    protected void compute() {
        // Perform task
    }
};

forkJoinPool.invoke(task);

50. Using RecursiveTask

ForkJoinPool forkJoinPool = new ForkJoinPool(4);

RecursiveTask<Integer> task = new RecursiveTask<Integer>() {
    @Override
    protected Integer compute() {
        // Perform task
        return 10;
    }
};

Integer result = forkJoinPool.invoke(task);