Question

我想理解这一点：

String string;
public Test(String string){
     this.string = string;
     .....
}

public void foo(newObjectPerCall o) {
        synchronized (o) {
            //each thread can enter here because the object passed is always different
            ....
            synchronized (string) {
                // acquire this lock if the String is free.
            }
        }
    }

public synchronized void function() {

}

public static void main(){
    Test test = new Test("hello");
    for(int i = 0; i < 10;i++){
         WorkerThread workerThread = new WorkerThread(test);
         workerThread.start(); 
   }
 }

线程类

public class WorkerThread extends Thread {

    private Test test;

    public WorkerThread(Test test) {
        this.test = test;
    }

    @Override
    public void run() {
        while (true) {
            test.foo(new Object());
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test.function();
        }
    }
}

我的怀疑是：

如果一个线程获得内部锁定，那么获取外部锁定的其他线程将保留在foo函数内？
在线程上，由于某些原因，仍然在foo函数之外，是否可以获取function内的测试实例锁？

Answer 1

如果一个线程获得内部锁，那么获取外部锁的其他线程将保留在foo函数中？

是。他们将阻止，等待获取string的监视器。

在线程上，由于某些原因，仍然在foo函数之外，这个可以在函数内获取测试实例的锁吗？

是的，它完全独立于其他显示器。 synchronized实例方法等同于其主体为

的方法

synchronized (this) {
    ...
}

如果没有其他线程已拥有this的监视器，则“新”线程可以获取它，无论其他监视器拥有什么。但是，由于所有工作线程都使用Test的相同实例，因此其中只有一个可以一次“进入”function()。这可以与另一个线程正在执行foo()同时进行。

Answer 2

对不起我只知道第一个问题的答案

 if one thread acquire the inner lock, other threads that acquired the outer lock, will remains inside the foo function?

是

理解java中的嵌套锁

2 个答案: