在实例级锁中，两个线程同时进入两个不同的synchrnozied方法

Question

在一次采访中，有人问我，关于多线程，假设在同一个对象上有两个线程(线程1和线程2)。Thread-1在synchronized method1()中，Thread-2能以任何方式在java中同时进入synchronized method2()吗？

我回答“不”。这里，当Thread-1处于synchronizedmethod1（）时，它必须持有对象监视器上的锁，并且只有当它退出synchronizedMethod1（）后才会释放对象监视器上锁。所以，Thread-2必须等待Thread-1释放对象监视器上的锁，这样它才能进入synchronizedmethod2（）。

但还是请告知Thread-2是否有任何方法，通过任何方式在java中同时输入同步方法2（）是否有任何hack如果要实现这个东西

下面是我的程序，现在我已经改变了实现，现在请告知，因为以下程序的输出是

inside M1()
t1--->RUNNABLE
inside M2()
t2--->RUNNABLE

下面是我更新的代码

public class Test {

     private final Object lockA = new Object();
     private final Object lockB = new Object();

    public  void m1() {
         synchronized(lockA) {
        try {
            System.out.println("inside M1()");
            Thread.sleep(100);         
        }
        catch (InterruptedException ie) 
        {}
         }
    }

    public  void m2() {
        synchronized(lockB) {
        try { 
            System.out.println("inside M2()");
            Thread.sleep(100); }
        catch (InterruptedException ie) {}
    }
    }

    public static void main(String[] args) throws InterruptedException {
        final Test t = new Test();
        Thread t1 = new Thread()
        { html" target="_blank">public void run() { t.m1(); } };
        Thread t2 = new Thread()
        { public void run() { t.m2(); } };

        t1.start();
        //Thread.sleep(500);

        t2.start();
      //  Thread.sleep(500);

        System.out.println("t1--->"+t1.getState());
        System.out.println("t2--->"+t2.getState());
    }
}

Answer 1

您的代码如下所示:

void method1(){
      synchronized(this) {
           //...
      }
}

synchronized void method2(){
      synchronized(this) {
           //...
      }
}

在您的代码中，两个线程不能同时进入两个方法以进行锁争用。您只能在不同的可运行实例上执行，即不同的this。

Answer 2

两个线程不能同时持有同一个锁。然而，仅仅因为线程在对象的< code>synchronized方法中，并不意味着它持有锁。例如，它可以对条件变量调用< code>await,并在等待时释放锁。这允许其他线程通过输入< code>synchronized方法来获取锁——毕竟，这正是您所期待的。

Answer 3

注意，在您的示例中，即使MyRunnable1类有一个method1（），并且您的run（）函数在循环中调用这个方法，线程也不会在任何事情上竞争。因为thread1和thread2是不同的实例，每个实例都有自己的method1（）副本，所以synchronized使用的锁是不同的，而不是一个锁。