在获取ReentrantReadWriteLock时调用对象的同步方法。另一个线程上的ReadLock

Question

谢谢你考虑我的问题，我认为这实际上是在问：

不太确定下面的代码会如何死锁。

其结构大致如下所示，有两个类:

< li >具有同步方法的主类工作器 < li >具有类级别同步方法的util类

Worker的< code>run方法会死锁，使< code>doSomething()不同步可以避免死锁。

真实应用程序的线程转储显示：

“Worker”线程被阻塞-正在等待监视器锁定--

此处的“schedule”线程是WAITING-thread State Details--

at jdk.internal.misc.Unsafe.park(Native Method)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:194)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:885)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireShared(AbstractQueuedSynchronizer.java:1009)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireShared(AbstractQueuedSynchronizer.java:1324)

java prettyprint-override">public class Worker {

    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public String getData() {

        try{
            readWriteLock.readLock().lock();
            return "Data";
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public synchronized void doSomething() {
        // blocked due to the invocation of Utils.scheduleTask
        int v = Utils.getIntValue();
        System.out.println(v);
    }

    public void run() {
        // A static method which creates a thread that accesses the ReadWriteLock
        Utils.scheduleTask(this::getData);

        // some other quick tasks in between
        // ...

        // then enter this synchronized method
        doSomething();
    }
}

public class Utils {

    static synchronized void scheduleTask(Runnable task) {

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1, r -> {
            Thread t = Executors.defaultThreadFactory().newThread(r);
            t.setName("schedule");
            return t;
        });

        executorService.schedule(task, 0L, TimeUnit.SECONDS);
    }

    static int getIntValue() {
        return 123;
    }
}

我认为这是由于静态同步方法schduleTask锁定了整个Utils类，然后在ExecutorService的线程可以获得Worker内部的ReentantReadWriteLock的ReadLock，Worker的另一种方法doThings（）锁定在Worker对象上（内在锁），因此2个线程正在相互等待。

我可能完全错了，但如果到目前为止没有错，我不确定这个的实例如何知道引用它的Worker实例被另一个线程锁定？

似乎当计划的< code>Runnable task正在运行时，即使< code>scheduleTask方法已经返回，Utils类仍然被锁定。

更新了scheduleTask以使用0秒延迟，更接近实际场景。

感谢您花时间考虑这个问题！

Answer 1

结果是，从< code>schedule线程调用了“Worker”的另一个< code>synchronized方法，并且在< code>ReentrantReadWriteLock上锁定了来自“Worker”超类的方法。WriteLock()...

“Worker”线程持有< code>WriteLock并等待监视器锁

“计划”线程持有Worker对象监视器锁并等待ReadLock