Скачать или смотреть How to Prevent Thread Blocking in Java with CompletableFuture

Discover effective techniques for managing thread execution in Java, using CompletableFuture to avoid blocking tasks and enhance concurrency.
---
This video is based on the question https://stackoverflow.com/q/75055627/ asked by the user 'Jetski111' ( https://stackoverflow.com/u/19114669/ ) and on the answer https://stackoverflow.com/a/75056757/ provided by the user 'Holger' ( https://stackoverflow.com/u/2711488/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Prevent thread blocking queued threads

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Prevent Thread Blocking in Java with CompletableFuture

Java developers often encounter situations where multiple tasks need to run concurrently, but some tasks can block others from execution. This can lead to inefficiencies and increased wait times, particularly when tasks are submitted to an ExecutorService. In this guide, we will explore a common issue related to thread blocking and present a solution using CompletableFuture.

The Problem: Thread Blocking

Imagine you have a task that integrates multiple executions where the same task (based on a specific string value) cannot run concurrently. Here’s a scenario to illustrate the problem:

You have a series of tasks that you submit using ExecutorService. For example:

[[See Video to Reveal this Text or Code Snippet]]

Each task simply prints out a string value and simulates a delay using Thread.sleep. However, if the same task (in this case, "hi") is being executed simultaneously by two threads, it can block the other tasks from running. This leads to a situation where only 4 out of the 5 tasks run concurrently until one is completed.

The Solution: Using CompletableFuture

To prevent this thread blocking situation, we can utilize CompletableFuture. This approach allows us to chain tasks based on their completion without introducing unnecessary blocking. Here's a breakdown of the solution:

Utilizing CompletableFuture with Atomic Operations

Maintaining a Task Map:
Use a ConcurrentHashMap to manage tasks. This allows for atomic updates and ensures that tasks can be safely added or completed without blocking other threads.

[[See Video to Reveal this Text or Code Snippet]]

Submitting Tasks:
Create a submission function that checks whether a task for the given key already exists. If it does, chain the new task to run after the existing one completes; if it doesn’t, schedule the job immediately.

[[See Video to Reveal this Text or Code Snippet]]

Task Definition:
Define each task as a Runnable. This keeps it simple and ensures that it executes without blocking any other tasks.

[[See Video to Reveal this Text or Code Snippet]]

Example Implementation

Here’s how the complete implementation would look:

[[See Video to Reveal this Text or Code Snippet]]

Key Takeaways

Atomic Task Management: Using ConcurrentHashMap allows for concurrent task execution without locking, greatly improving efficiency.

Chaining Tasks: CompletableFuture enables chaining of tasks based on completion, thus preventing any blocking.

Concurrency Handling: This method ensures that even if you have the same task being submitted multiple times, they will not block other executions.

By leveraging these techniques, Java developers can enhance concurrency in their applications and significantly reduce thread blocking, leading to a smoother and more efficient performance.

If you have any questions about this implementation or thread management in Java, feel free to reach out. Happy coding!