🎏 fucking-java-concurrency
Simple showcases of Java concurrency problems, seeing
🍎 Reasons to organize Demo
- The actual phenomenon that can be observed
🙈 is more intuitive and more trustworthy than the concurrency principle mentioned🙊 . - The
Javalanguage standard library supports threads, multithreading is heavily used in the language itself (such asGC) and applications (the server side). - Concurrency program design, in the analysis and implementation, the complexity is greatly increased. If you do not fully understand and systematically analyze the concurrent logic, and write code at will, it is not an exaggeration to describe such a program as "accidentally" running with the correct result.
- The demos here do not give explanations and discussions, and they are all entry-level
. For more information, please loop up the concurrency materials by yourself.
- The demos here do not give explanations and discussions, and they are all entry-level
Examples of concurrency problems you encountered in development are welcome to provide (submit Issue) or share (pull request after Fork)!
🍺 Update without synchronization cannot be read in another thread🍺 Infinite loop ofHashMap🍺 Combined state read invalid combination🍺 longvariable read invalid value🍺 the result of concurrency count without synchronization is wrong🍺 Synchronization on mutable fields🍺 Deadlock caused by the symmetric locks🍺 Livelock caused by reentrant locks
🍺 Update without synchronization cannot be read in another thread
Demo class NoPublishDemo.
Demo description
Set the field stop to true in the main thread to control the exit of the task thread started in main.
Problem statement
After the main thread field stop is true, the task thread continues to run, that is, no new value has been read in the task thread.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.NoPublishDemo🍺 Infinite loop of HashMap
This problem has been explained in many places.
The Demo class HashMapHangDemo can reproduce this problem.
Demo description
Two task threads are opened in the main thread to perform the put operation of HashMap. The main thread does the get operation.
Problem statement
The main thread Block is determined by no continuous output, that is, the endless loop of HashMap appears.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.HashMapHangDemo🍺 Combined state read invalid combination
When programming, multiple state records will be required (state can be a POJO object or ints, etc.).
It is often seen that the multi-state read and write code is not synchronized, and the person who write it will naturally ignore the issue of thread safety.
Invalid combinations are combinations that have never been set.
Demo description
The main thread modifies multiple states. For the convenience of checking, each write has a fixed relationship: the second state is twice the value of the first state. Read multiple states in a task thread.
Demo class InvalidCombinationStateDemo.
Problem statement
The second state read in the task thread is not twice the value of the first state, that is, an invalid value.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.InvalidCombinationStateDemo🍺 long variable read invalid value
An invalid value is a value that has never been set.
Reading and writing of long variables is not atomic and will be divided into two 4-byte operations.
Demo class InvalidLongDemo.
Demo description
The main thread modifies the long variable. For the convenience of checking, the upper 4 bytes and the lower 4 bytes of the long value written each time are the same. Read the long variable in the task thread.
Problem statement
In the task thread, a long variable whose upper 4 bytes and lower 4 bytes are different is read, which is an invalid value.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.InvalidLongDemo🍺 the result of concurrency count without synchronization is wrong
Demo class WrongCounterDemo.
Demo description
Two task threads are opened in the main thread to execute concurrent incrementing counts. Main thread final result check.
Problem statement
The count value is incorrect.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.WrongCounterDemo🍺 Synchronization on mutable fields
It is common to see synchronization code on a volatile field, and the person who write it will naturally feel that this is safe and correct.
# For problem analysis, see the article Synchronization on mutable fields.
Demo class SynchronizationOnMutableFieldDemo.
Demo description
Two task threads are opened in the main thread to execute addListener. Main thread final result check.
Problem statement
The final count of Listeners is incorrect.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.SynchronizationOnMutableFieldDemo🍺 Deadlock caused by the symmetric locks
# For problem analysis, see the article Synchronization on mutable fields
Demo class SymmetricLockDeadlockDemo.
Demo description
Two task threads are opened in the main thread for execution.
Problem statement
Task thread deadlocked.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.SymmetricLockDeadlockDemo🍺 Livelock caused by reentrant locks
# For a problem description, see the paragraph about livelocks in this article
Demo class ReentrantLockLivelockDemo.
Demo description
Two task threads are trying to acquire a lock that the other thread holds while holding their own lock.
Problem statement
While the threads are releasing their own lock constantly, they are also re-locking it immediately, denying the other thread a chance to acquire both locks. Since both threads are not blocked from executing but blocked from doing meaningful work, this is a livelock.
Quickly run
./mvnw compile exec:java -Dexec.mainClass=fucking.concurrency.demo.ReentrantLockLivelockDemo