# java.util.concurrent

***

**1. Creating and Using a Thread Pool**

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

**2. Executing Tasks Asynchronously**

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

**3. Scheduling Tasks with ScheduledThreadPoolExecutor**

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

**4. Using a CountDownLatch to Wait for Multiple Tasks**

```java
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**

```java
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**

```java
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**

```java
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**

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

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

**9. Using ConcurrentHashMap for Concurrent Access to Maps**

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

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

**10. Using AtomicInteger for Concurrent Incrementation**

```java
AtomicInteger counter = new AtomicInteger(0);

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

**11. Using AtomicReference for Concurrent Modification of Reference**

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

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

**12. Using Executors.newCachedThreadPool()**

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

**13. Using Executors.newSingleThreadExecutor()**

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

**14. Using CompletableFuture.allOf()**

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

**15. Using CompletableFuture.anyOf()**

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

**16. Using Executors.newWorkStealingPool()**

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

**17. Using Executors.newScheduledThreadPool()**

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

**18. Using Executors.newFixedThreadPool() with a Queue**

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

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

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

**20. Using Executors.newSingleThreadScheduledExecutor()**

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

**21. Using CompletableFuture.thenAcceptBoth()**

```java
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()**

```java
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()**

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

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

**24. Using CompletableFuture.handle()**

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

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

**25. Using CompletableFuture.exceptionally()**

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

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

**26. Using CompletableFuture.applyToEither()**

```java
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()**

```java
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**

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

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

**29. Using LinkedBlockingDeque**

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

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

**30. Using PriorityQueue**

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

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

**31. Using SynchronousQueue**

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

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

**32. Using ReentrantLock**

```java
ReentrantLock lock = new ReentrantLock();

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

**33. Using Condition**

```java
Condition condition = lock.newCondition();

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

**34. Using Semaphore with Fairness**

```java
Semaphore semaphore = new Semaphore(3, true);

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

**35. Using CountdownLatch with Timeouts**

```java
CountDownLatch latch = new CountDownLatch(4);

latch.await(5, TimeUnit.SECONDS);
```

**36. Using Phaser with Multiple Phases**

```java
Phaser phaser = new Phaser(5);

phaser.register();

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

**37. Using StampedLock for Optimistic Concurrency**

```java
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**

```java
CyclicBarrier barrier = new CyclicBarrier(4);

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

**39. Using ThreadLocal for Thread-Local Storage**

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

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

**40. Using Executors.newWorkStealingPool(boolean)**

```java
ExecutorService executorService = Executors.newWorkStealingPool(true);

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

**41. Using Executors.newSingleThreadExecutor(ThreadFactory)**

```java
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()**

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

future.completeExceptionally(new RuntimeException());
```

**43. Using CompletableFuture.thenRun()**

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

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

**44. Using CompletableFuture.orTimeout()**

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

future.orTimeout(5, TimeUnit.SECONDS);
```

**45. Using SynchronousQueue with Consumers**

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

queue.put(10);

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

queue.take(consumer);
```

**46. Using LinkedBlockingQueue with Iterators**

```java
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**

```java
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**

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

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

**49. Using ForkJoinPool**

```java
ForkJoinPool forkJoinPool = new ForkJoinPool(4);

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

forkJoinPool.invoke(task);
```

**50. Using RecursiveTask**

```java
ForkJoinPool forkJoinPool = new ForkJoinPool(4);

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

Integer result = forkJoinPool.invoke(task);
```