java - 同步方法中的线程锁定

Question

我读到 java 中的每个对象都有一个锁。当用该对象调用同步方法时，线程将获取该锁。同时线程可以获得多个锁。

public class ThreadTes extends Thread{

public static void main(String[] args){

    ThreadTes t=new ThreadTes();
    t.start();

}
synchronized public void r(){
    System.out.println("in r method");
    this.r1();
}
synchronized public void r1(){
    System.out.println("in r1 method");
}
public void run(){
    ThreadTes tt=new ThreadTes();
    tt.r();        
}
}

在上面的代码中，一个同步方法 r() 从 run 中调用，然后该特定线程从 r() 中再次获取对象 tt.now 的锁 r1() 被调用。

我的问题是，当 tt 锁在进入 r() 时获得，那么它如何进入 r1() ，因为该对象上的锁已经获得。

public class ThreadTes extends Thread{

public static void main(String[] args){

    ThreadTes t=new ThreadTes();
    t.start();

}
synchronized public void r(){
    System.out.println("in r method");
    ThreadTes ttt=new ThreadTes();
    ttt.r1();
}
synchronized public void r1(){
    System.out.println("in r1 method");
}
public void run(){
    ThreadTes tt=new ThreadTes();
    tt.r();   

}
}

当我运行两个不同的对象时，为什么这段代码会运行...

Answer 1

Java 的内在锁(与 synchronized 关键字一起使用)是可重入的。输入 r1 所需的锁与输入 r 所需的锁相同。允许已经拥有锁的线程重新获取它。您可以想象有一个计数器，用于记录线程获得同一锁的次数。在方法 r1 中，调用线程已两次获取相同的锁。只有当“计数”归零时，锁才对其他线程可用；也就是说，一旦获得锁的线程释放锁的次数与获得锁的次数完全相同。

编辑:这里有五个线程的示例，每个线程在两个需要相同锁的相互递归方法之间跳转。运行这个例子可以看到，直到之前的线程完全递归完毕，才会有线程进入methodOne，同一个线程连续进入相同(或不同)的是没有问题的。 code>synchronized 共享同一锁的方法。

public class LockExample {
    private static synchronized void methodOne(int depth) {
        if (depth == 0) {
            return;
        } else {
            System.out.println(Thread.currentThread().getName() + " methodOne (in), depth " + depth);
            methodTwo(depth - 1);
            System.out.println(Thread.currentThread().getName() + " methodOne (out), depth " + depth);
        }
    }

    private static synchronized void methodTwo(int depth) {
        if (depth == 0) {
            return;
        } else {
            System.out.println(Thread.currentThread().getName() + " methodTwo (in), depth " + depth);
            methodOne(depth - 1);
            System.out.println(Thread.currentThread().getName() + " methodTwo (out), depth " + depth);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    methodOne(10);
                }
            });
            t.setName("Thread" + i);
            t.start();
        }
    }
}

示例输出(抱歉长度):

Thread0 methodOne (in), depth 10
Thread0 methodTwo (in), depth 9
Thread0 methodOne (in), depth 8
Thread0 methodTwo (in), depth 7
Thread0 methodOne (in), depth 6
Thread0 methodTwo (in), depth 5
Thread0 methodOne (in), depth 4
Thread0 methodTwo (in), depth 3
Thread0 methodOne (in), depth 2
Thread0 methodTwo (in), depth 1
Thread0 methodTwo (out), depth 1
Thread0 methodOne (out), depth 2
Thread0 methodTwo (out), depth 3
Thread0 methodOne (out), depth 4
Thread0 methodTwo (out), depth 5
Thread0 methodOne (out), depth 6
Thread0 methodTwo (out), depth 7
Thread0 methodOne (out), depth 8
Thread0 methodTwo (out), depth 9
Thread0 methodOne (out), depth 10
Thread2 methodOne (in), depth 10
Thread2 methodTwo (in), depth 9
Thread2 methodOne (in), depth 8
Thread2 methodTwo (in), depth 7
Thread2 methodOne (in), depth 6
Thread2 methodTwo (in), depth 5
Thread2 methodOne (in), depth 4
Thread2 methodTwo (in), depth 3
Thread2 methodOne (in), depth 2
Thread2 methodTwo (in), depth 1
Thread2 methodTwo (out), depth 1
Thread2 methodOne (out), depth 2
Thread2 methodTwo (out), depth 3
Thread2 methodOne (out), depth 4
Thread2 methodTwo (out), depth 5
Thread2 methodOne (out), depth 6
Thread2 methodTwo (out), depth 7
Thread2 methodOne (out), depth 8
Thread2 methodTwo (out), depth 9
Thread2 methodOne (out), depth 10
Thread3 methodOne (in), depth 10
Thread3 methodTwo (in), depth 9
Thread3 methodOne (in), depth 8
Thread3 methodTwo (in), depth 7
Thread3 methodOne (in), depth 6
Thread3 methodTwo (in), depth 5
Thread3 methodOne (in), depth 4
Thread3 methodTwo (in), depth 3
Thread3 methodOne (in), depth 2
Thread3 methodTwo (in), depth 1
Thread3 methodTwo (out), depth 1
Thread3 methodOne (out), depth 2
Thread3 methodTwo (out), depth 3
Thread3 methodOne (out), depth 4
Thread3 methodTwo (out), depth 5
Thread3 methodOne (out), depth 6
Thread3 methodTwo (out), depth 7
Thread3 methodOne (out), depth 8
Thread3 methodTwo (out), depth 9
Thread3 methodOne (out), depth 10
Thread1 methodOne (in), depth 10
Thread1 methodTwo (in), depth 9
Thread1 methodOne (in), depth 8
Thread1 methodTwo (in), depth 7
Thread1 methodOne (in), depth 6
Thread1 methodTwo (in), depth 5
Thread1 methodOne (in), depth 4
Thread1 methodTwo (in), depth 3
Thread1 methodOne (in), depth 2
Thread1 methodTwo (in), depth 1
Thread1 methodTwo (out), depth 1
Thread1 methodOne (out), depth 2
Thread1 methodTwo (out), depth 3
Thread1 methodOne (out), depth 4
Thread1 methodTwo (out), depth 5
Thread1 methodOne (out), depth 6
Thread1 methodTwo (out), depth 7
Thread1 methodOne (out), depth 8
Thread1 methodTwo (out), depth 9
Thread1 methodOne (out), depth 10
Thread4 methodOne (in), depth 10
Thread4 methodTwo (in), depth 9
Thread4 methodOne (in), depth 8
Thread4 methodTwo (in), depth 7
Thread4 methodOne (in), depth 6
Thread4 methodTwo (in), depth 5
Thread4 methodOne (in), depth 4
Thread4 methodTwo (in), depth 3
Thread4 methodOne (in), depth 2
Thread4 methodTwo (in), depth 1
Thread4 methodTwo (out), depth 1
Thread4 methodOne (out), depth 2
Thread4 methodTwo (out), depth 3
Thread4 methodOne (out), depth 4
Thread4 methodTwo (out), depth 5
Thread4 methodOne (out), depth 6
Thread4 methodTwo (out), depth 7
Thread4 methodOne (out), depth 8
Thread4 methodTwo (out), depth 9
Thread4 methodOne (out), depth 10