CIP - avoid liveness hazards
We use lock to ensure thread safety, but indiscriminate use of locking can cause lock-ordering deadlocks.
# deadly embrace
When thread A holds lock L and try to acquire lock M, but at the same time thread B holds lock M and try to acquire lock L, both threads will wait forever.
# lock-ordering deadlock
This problem come about when two threads attempt to acquire the same locks in different order.
A program will be free of lock-ordering deadlocks if all threads acquire the locks they need in a fixed order.
/** code sample for lock-ordering deadlock */
public class LeftRightlock {
private final Object left = new Object();
private final Object right = new Object();
public void leftRight() {
synchronized (left) {
synchronized (right) {
// ...
}
}
}
public void rightLeft() {
synchronized (right) {
synchronized (left) {
// ...
}
}
}
}
# dynamic lock order deadlock
in fact, the lock order depends on the order of arguments passed to the method:
public void transferMoney(final Account fromAcct,
final Account toAcct,
final double amount) throws Exception {
synchronized (fromAcct) {
synchronized (toAcct) {
if (fromAcct.getBalance() < amount) {
throw new Exception("insufficient balance");
} else {
fromAcct.debitt(amount);
toAcct.credit(amount);
}
}
}
}
to solve the above problem, we can use System.identityHashCode(obj) to decide the order.
# Avoid deadlock
One technique for detecting and recovering from deadlocks is to use timed tryLock of the explicit lock instead of intrinsic locking.
＃starvation
Startvation occurs when a thread perpetually denied access to resources it needs.
Starvation can be caused by inappropriate use of thread priorities.
# priority
The thread API defines 10 priority levels that JVM can map to OS scheduling priorities, this mapping is platform-specific. Some different java priorities can map to same OS priority.
# livelock
Livelock is also a form of liveness failure in which a thread, while not blocked, still cannot make progress because it keeps retrying an operation that will always fail.
The solution for livelock is to introduce some randomness into retry mechanism.