让我先把结论说出来——对私有字段的锁定对于稍微复杂一点的多线程程序是不起作用的。这是因为多线程是一个全局问题。本地化同步是不可能的，除非你以一种非常防御的方式写(例如，复制所有传递给其他线程的内容)。
下面是详细的解释:
同步包括三个部分:原子性、可见性和有序性
同步块是非常粗糙的同步级别。正如您所期望的那样，它加强了可见性和排序。但是对于原子性，它并不能提供太多的保护。原子性要求程序的全局知识，而不是局部知识。(这使得多线程编程非常困难)
假设我们有一个Account类，它有存取款方法。它们都是基于一个私有锁进行同步的，就像这样:
class Account {
private Object lock = new Object();
void withdraw(int amount) {
synchronized(lock) {
// ...
}
}
void deposit(int amount) {
synchronized(lock) {
// ...
}
}
}
考虑到我们需要实现一个更高级别的类来处理传输，就像这样:
class AccountManager {
void transfer(Account fromAcc, Account toAcc, int amount) {
if (fromAcc.getBalance() > amount) {
fromAcc.setBalance(fromAcc.getBalance() - amount);
toAcc.setBalance(toAcc.getBalance + amount);
}
}
}
假设我们现在有两个账户，
Account john;
Account marry;
如果Account.deposit()和Account.withdraw()被内部锁定。这将导致问题时，我们有2个线程工作:
// Some thread
void threadA() {
john.withdraw(500);
}
// Another thread
void threadB() {
accountManager.transfer(john, marry, 100);
}
因为线程a和线程b有可能同时运行。线程B完成条件检查，线程A退出，线程B再次退出。这意味着即使约翰的账户上没有足够的钱，我们也可以从他那里提取100美元。这将打破原子性。
您可能会提出:为什么不将withdraw()和deposit()添加到AccountManager中呢?但是根据这个提议，我们需要创建一个多线程安全的Map，将不同的帐户映射到它们的锁。我们需要在执行后删除锁(否则会泄漏内存)。我们还需要确保没有其他用户直接访问Account.withdraw()。这将引入许多微妙的错误。
正确且最常用的方法是在Account中公开锁。并让AccountManager使用锁。但在这种情况下，为什么不直接使用对象本身呢?
class Account {
synchronized void withdraw(int amount) {
// ...
}
synchronized void deposit(int amount) {
// ...
}
}
class AccountManager {
void transfer(Account fromAcc, Account toAcc, int amount) {
// Ensure locking order to prevent deadlock
Account firstLock = fromAcc.hashCode() < toAcc.hashCode() ? fromAcc : toAcc;
Account secondLock = fromAcc.hashCode() < toAcc.hashCode() ? toAcc : fromAcc;
synchronized(firstLock) {
synchronized(secondLock) {
if (fromAcc.getBalance() > amount) {
fromAcc.setBalance(fromAcc.getBalance() - amount);
toAcc.setBalance(toAcc.getBalance + amount);
}
}
}
}
}
简而言之，私有锁不适用于稍微复杂一点的多线程程序。
(转载自https://stackoverflow.com/a/67877650/474197)
