同步对象锁定混淆

Question

我在学习K

public class AccountDanger implements Runnable {
  private Account account = new Account();
  public void run() {
    for(int x =0 ; x < 5 ; x++){
      makeWithdrawl(10);
      if(account.getBalance() < 0 ){
        System.out.println("account is overdrawn");
      }
    }
  }
  public static void main(String[] args){
    AccountDanger accountDanger = new AccountDanger();
    Thread one = new Thread(accountDanger);
    Thread two = new Thread(accountDanger);
    one.setName("Fred");
    two.setName("Lucy");
    one.start();
    two.start();
  }

  private synchronized void makeWithdrawl(int amt){
    if(account.getBalance() >= amt){
      System.out.println(Thread.currentThread().getName() + " is going to withdraw");

    try{
      Thread.sleep(500);
    }
    catch(InterruptedException e) {
      e.printStackTrace();
    }
    account.withdraw(amt);
    System.out.println(Thread.currentThread().getName() + " completes the withdrawl");
   }
    else{
      System.out.println("Not enough in account for " + Thread.currentThread().getName() + " to withdraw " +
        account.getBalance());
    }
 }
}

K

当一个方法从同步块中执行代码时，代码被称为在同步上下文中执行。当您同步一个方法时，用于调用该方法的对象是必须获取其锁的对象。但是当我们同步代码块时，您必须指定要使用哪个对象的锁作为锁。

在本例中，会在AccountDanger实例或Account对象上获取锁吗？我想应该是这样的。我感觉正确吗？如果它是AccountDanger对象，并且一个线程已获得AccountDanger锁，那么其他线程是否能够调用非同步方法？

Answer 1

private synchronized void makeWithdrawl(int amt){
     //is implicitly acquiring lock on this object (AccountDanger object)              
}

因此，在本例中，调用此方法的第一个线程将进入synchronized块获取this对象监视器并保持它，并且除了第一个线程本身之外，没有其他线程可以在this上再次获取监视器锁。调用此方法的所有其他线程都将阻塞，直到第一个线程释放锁并释放监视器。

注意：用于同步块的锁本质上是可重入的。

Answer 2

所以在这个例子中，锁会在Account tDanger实例或帐户对象上获取吗？

对我经常看到的一个技巧是，当你只有一小段真正需要同步的代码时，在上同步这个。例如：

int balance = -1;
synchronized(this) {
  balance = account.getBalance();
  account.withdraw(amt);
}
//IO, etc. after that.

一般来说，这会加快速度。