在线程中使用同步

Question

以下内容可以理解为什么？
我已经浏览了这篇帖子，但仍然无法组装它。

code1:

synchronized(this){ 
// some code
}

code2:

Object lock = new Object();

synchronized(lock){
// some code
}

有任何教程或一些链接来解释同步，就像他们向孩子解释一样？

Answer 1

基本上，Java 中的每个对象都有一个关联的“锁”。

当线程到达对synchronized(something)的调用时，它必须在继续之前获取某物的锁。如果你想一次只允许一个线程修改一个对象的状态，最明显的事情就是同步该对象的锁。如果允许并行调用不同的方法，则需要不同的锁。

如果您编写synchronized(this)，或者只是synchronized，则线程必须获取与当前对象（调用其方法）关联的锁。

请注意，从 Java 5.0 开始，并发包提供了正确的 锁可以用来代替同步。

Answer 2

在已经给出的优秀答案中没有提到的一件事是 code1 和 code2 之间的区别。在 code1 中，同步是在其中找到代码的对象的实例上进行的，而在 code2 中，同步是在对象内的特定锁定对象上进行的。

如果封闭类中只有两个同步块，则两者之间没有功能差异，但请考虑这一点：

class CodeOneClass {
  ...
  synchronized(this) {   // or merely "synchronized" - it defaults to this
      first protected code block
  }
  ...
  synchronized(this) {   
      second protected code block
  }
...
}

class CodeTwoClass {
  ...
  Object lock1 = new Object();
  synchronized(lock1) {   
      first protected code block
  }
  ...
  Object lock2 = new Object();
  synchronized(lock2) {   
      second protected code block
  }
...
}

如果两个线程尝试使用 CodeOneClass 的同一实例，则只能使用其中一个同时在两个受保护的代码块中中。

但是使用第二个习惯用法，您可以灵活地表示一个线程位于第一个受保护块中是安全的，而另一个线程位于另一个受保护块中是安全的。请注意，如果锁相同（都在同一个锁对象上同步），则行为将与第一个相同。

还有其他差异。一些作者开始指出 synchronized(this) 的问题 - 我会向您指出另一篇关于 SO 的文章：
我强烈建议阅读它，它链接的

三个帖子到。

Answer 3

将代码放在 synchronized 块中本质上意味着，“一旦此代码开始运行，需要使用此对象的其他代码就无法同时运行。”

因此，如果线程 #2 正在执行 code2 块中的代码，那么当涉及到 synchronized(lock) 代码时，它必须有效地环顾所有其他线程以确保此时没有其他人正在使用 lock 对象运行“同步”代码。线程 #1 肯定同时运行一些代码，但它可能是完全不相关的代码。如果是这样，线程#2 就可以安全地开始运行“some code”内容。

同时，如果线程 #1 到达 synchronized(this) 块，它也必须暂停并查看是否有其他线程正在使用 this。如果 this 与 lock 是同一个对象，我们就会遇到问题。我们被告知只有一个线程可以同时使用该对象（在同步块中）。然而线程 #2 已经在使用它了。线程#1 只需要等待...等待...等待...直到线程#2 最终完成。然后我们就可以继续了。

最终结果是一次只能运行一个同步块（当然是针对特定对象）。

Answer 4

假设您有一个 Account 对象，它有一个方法：

void debit(long debitAmount, Account beneficiary) throws InsufficientFundsException
{
   if (accountBalance >= debitAmount) {
      accountBalance -= debitAmount;
      beneficiary.credit(debitAmount);
   }
   else {
      throw new InsufficientFundsException();
   }
}

现在假设您有一个余额为 100 欧元的帐户，并且您有两次尝试借记 70 欧元。如果两次借记同时发生，您可以得到如下的竞争条件：

• 第一次借记检查帐户余额：100 >= 70，因此成功
• 第二次借记检查帐户余额：100 >= 70、这样成功
• 第一次借记执行；账户余额变为 30
• 秒借方执行；账户余额变为-40。 不应该允许

我们可以通过同步Account对象的锁来防止这种可怕的情况：

void debit(long debitAmount, Account beneficiary) throws InsufficientFundsException
{
   synchronized (this) {
      if (accountBalance >= debitAmount) {
         accountBalance -= debitAmount;
         beneficiary.credit(debitAmount);
      }
      else {
         throw new InsufficientFundsException();
      }
   }
}

这可以确保对帐户余额和借方的测试可以'不会被帐户余额的另一次测试中断。

Sun Java 教程 是获取以下信息的好地方：并发和锁定。