Question

两个示例场景：

第一

public synchronized void foo1(){
              .....
}

public void foo2(){
              .....
}

和线程循环是：

 public void run() {
        while (true) {
           foo1();
           foo2();
        }
    }

如果我运行10个线程，其中一个获取锁定foo1()其他想要执行foo1的线程将在foo1()之外等待，或者它们可以循环并执行{{1}内的代码1}}？

第二

foo2

和线程循环是：

public void foo1(){
      lock.lock();
      ....
      lock.unlock();
}

public void foo2(){

}

如果我运行10个线程，其中一个获取public void run() { while (true) { foo1(); foo2(); } }内的锁定，在这种情况下，想要执行foo1()的线程不会在foo1之外被阻止？

Answer 1

如果我运行10个线程，其中一个获取锁定在foo1（）内其他想要执行foo1的线程将在foo1（）之外等待，或者它们可以在foo2中循环并执行代码？

假设他们在同一个对象上被调用，他们都会在需要执行foo1()时排队。任何已经完成 foo1()的迭代都可以执行foo2() ...但是当他们需要执行foo1()时，它会在下一次迭代时再次排队

如果我运行10个线程，其中一个获取foo1（）内的锁定，在这种情况下，想要执行foo1的线程不会被阻止在foo1之外？

他们没有被在 foo1()之外阻止，但他们将被 foo1()内的阻止。

您的示例之间唯一的区别在于堆栈跟踪。从根本上说，在这两种情况下，执行foo1()的主要块需要线程拥有锁。

（请注意，您的unlock来电应该在finally区块中。）