java - 确定哪个线程获得了同步 key

Question

我正在学习如何使用线程，我遇到了这个问题，对于给定的代码，我需要说明某个线程是否能够访问某个函数。这是代码:

public class InsideClass{}

public class SyncClass{
    private InsideClass in1;
    private InsideClass in2;

public SyncClass(InsideClass i, InsideClass i2){ in1 = i; in2 = i2; }

public synchronized void func1() { System.out.println("in func1"); }

public void func2() { synchronized(in1) { System.out.println("in func2"); }}

public static synchronized void func3() { System.out.println("in func3"); }

public void func4() { synchronized(in2) { System.out.println("in func4"); }}

public synchronized void func5() {
    synchronized(in1) {
        synchronized(in2){ System.out.println("in func5"); }}
}}

public class MyThread extends Thread{
    private SyncClass sc;

    public MyThread(SyncClass s) {
        sc = s;
    }

    public void run(){
        sc.func1();
        sc.func2();
        SyncClass.func3();
        sc.func4();
        sc.func5();
       }
    }

public class Sys {
    public static void main(String[] args) {
        InsideClass in1 = new InsideClass();
        InsideClass in2= new InsideClass();
        SyncClass s1 = new SyncClass(in1,in2);
        SyncClass s2 = new SyncClass(in2,in1);
        MyThread t1 = new MyThread(s1);
        MyThread t2 = new MyThread(s2);
        t1.start();
        t2.start();
    }
}

问题是这样的，假设 t1 正在执行 task(i) (i=1,2,3,4)，t2 是否能够执行 func(i+1) 还是会被阻塞？解释。我写下了完整的问题以防万一不清楚。

1) 假设 t1 正在执行 func1

• a) t2 能否执行 func1？

• b) t2 能否执行 func2？

• c) t2 能否执行 func3？

• d) t2 能否执行 func4？

2) 假设 t1 正在执行 func2。

• a) t2 能否执行 func2？

• b) t2 能否执行 func3？

• c) t2 能否执行 func4？

3) 假设 t1 正在执行 func3

• a) t2 能否执行 func3？

• b) t2 能否执行 func4？

4) 假设 t1 正在执行 func4

• a) t2 能否执行 func4？

5) func5 有一个独特的实现。

• a) 这种方法可以生成多少种不同的锁？指定他们是谁。

• b) func5 出现的问题是什么？你会如何解决这个问题？

我不是在寻找所有这些问题的答案(即使以防万一它会很好)，但我想得到一个对象的含义的解释(在这个例子中 in1/in2)在同步块(synchronized block)内，当使用这些对象 (s1,s2) 初始化 2 个其他对象时。如果 t1 正在执行同步的 func1，这对执行 func2 的尝试有何影响？ (s1 和 s2 是用相同的对象初始化的事实如何影响这个问题)。

我希望我的问题足够清楚。谢谢!

Answer 1

同步 语句获取给定对象的内部锁，然后执行其主体，然后释放 锁。

Object lock = new Object();
synchronized(lock) {
    ...body...
}

Java Runtime Environment (JRE) 永远不允许两个线程同时获取同一个对象的内在锁。如果一个线程获取了锁，那么第二个尝试获取锁的线程将被阻塞，直到第一个线程释放锁。

重要的是要知道无论线程如何退出...body... 锁都会被释放。无论它是 return 还是 break ，它是否只是跑到最后，或者它是否抛出异常，都无关紧要。无论如何都会释放锁。

---

有一种快捷方式可以编写一个整个主体都同步的成员函数。

这个:

class MyClass {
    synchronized void foobar(...args...) { ...body... }
}

意思和这个完全一样:

class MyClass {
    void foobar(...args...) {
        synchronized(this) { ...body... }
    }
}

synchronized static 函数也是如此，只是它在类对象上同步。

这个:

class MyClass {
    synchronized static void foobar(...args...) { ...body... }
}

意思和这个完全一样:

class MyClass {
    static void foobar(...args...) {
        synchronized(MyClass.class) { ...body... }
    }
}

---

记住变量和对象之间的区别很重要。如果变量 foo 引用两个不同的对象，则两个线程可以同时进入 synchronized(foo){...} block 两种不同的语境。 (仔细考虑您的 in1 和 in2 成员变量!)同样，两个不同的线程可以同时调用相同的 synchronized 成员函数，如果这两个线程在不同的对象上运行。 (您的示例有两个不同的 SyncClass 实例!)