(实验)Java一个线程用synchronized嵌套锁多个对象时调用wait()只释放wait函数关联的所对象还是释放所有锁对象

实验是在JDK1.8下做的。


题目起的比较拗口,其实用代码说明起来更简单,如下所示:

public class MultiSynchronizedTest {

    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    private static class Task1 implements Runnable {
        @Override
        public void run() {
            synchronized (lock1) {
                synchronized (lock2) {
                    try {
                        lock1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

当一个线程运行Task1时,通过synchronized顺序获得了lock1和lock2的锁,然后在最里层调用锁(lock1或者lock2,下面以lock1为例)的wait()函数,然后按照教科书式的说法,线程进入waiting状态,释放锁,等别的线程调用notify()或者notifyAll()来再次唤醒到runnable状态。那么问题来了,释放锁是一个笼统的说法,到底是只释放wait()函数关联的对象锁(即lock1)还是释放线程当时持有的所有锁(即lock1和lock2)。


直观上来讲,我只调用了lock1.wait()函数,当然只释放lock1。而且我调用哪个对象的wait()就只释放哪个对象的锁,这样程序也更可控。在这里提前先告诉大家,经过实验,结果确实是上面讲的那样:一个线程通过synchronized嵌套锁住多个对象,然后在最里层调用wait()函数,只释放wait()函数关联的锁对象,而不是释放线程当时持有的全部锁


但是我们也可以直观说线程调用锁对象的wait()函数时,就是释放线程当时持有的所有锁嘛——要不通过wait()自身某种回调机制来释放,或者JVM使得线程进入waiting(或者time_waiting)状态时会统一把持有的锁都释放了。但是直观归直观,信息科学技术(拔的太高了?IT码活)永远是个实践出真知的领域,Object.wait()是个native函数,看明白原理要看cpp源码,JVM就更不用说了,在不研究源码的前提下,做个实验室最方便了。


下面我们用两把全局锁,两个线程和jstack、jps工具来验证下。完整的代码如下:

package com.jxshen.example.jdk.lock;

public class MultiSynchronizedTest {

    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) {
        Runnable task1 = new Task1();
        Thread thread1 = new Thread(task1, "task1");
        thread1.start();
        Runnable task2 = new Task2();
        Thread thread2 = new Thread(task2, "task2");
        thread2.start();
    }

    private static class Task1 implements Runnable {

        @Override
        public void run() {
            synchronized (lock1) {
                System.out.println("Task1 obtain lock1");
                synchronized (lock2) {
                    System.out.println("Task1 obtain lock2");
                    try {
                        lock1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    private static class Task2 implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) {
                System.out.println("Task2 obtain lock2");
            }
        }
    }
}

lock1和lock2是两个静态全局锁,线程task1(代码里我把线程名和任务名取做一致,到时候看jstack方便点)顺序获得lock1和lock2,并在最里层马上调用lock1.wait()。为了保证线程task2在task1释放锁之后尝试获取锁,task2在一开始先sleep 2秒。注意线程task2尝试synchronized的锁一定要和task1调用wait()关联的锁不一样,否则task2马上能够获得锁。这里task2尝试获取lock2,如果线程调用wait()只释放关联的锁对象,那么task2获取不到lock2,会阻塞在那;否则task2获取lock2成功,马上打印出字符串。


运行上面的程序,从控制台(图1)可以看出线程task2并没有进入synchronized块。然后我们通过jstack工具看下这两个线程的具体状态。

(实验)Java一个线程用synchronized嵌套锁多个对象时调用wait()只释放wait函数关联的所对象还是释放所有锁对象_第1张图片

图1


首先在命令行输入“jps -l”,获得图2所示:


图2

可以找到我们运行程序对应的进程号pid为27584。jps这个jdk工具可以查看当前用户java进程的简要状态,参数有l和v,具体用法可以网上查找。注意jps只能给出归属当前用户的java进程,要是想查找全部的java进程,windows下要利用下任务管理器,linux下需要top或者ps命令。


然后我们在命令行输入“jstack 27584”,获得图3所示:

(实验)Java一个线程用synchronized嵌套锁多个对象时调用wait()只释放wait函数关联的所对象还是释放所有锁对象_第2张图片

图3

jstack具体展示了某个jvm进程在某时刻的堆栈快照。我们可以看到线程task1依次获取了两个锁,分别是0x00000000d5a5b500(lock1)和0x00000000d5a5b510(lock2)。随后线程task1进入了waiting(on object monitor)状态,等待的锁对象是0x00000000d5a5b500(lock1),对应代码里的lock1.wait()。


然后看线程task2,处于blocked(on object monitor)状态,等待的锁对象是0x00000000d5a5b510(lock2)。可以证明线程task1在wait后并没有释放掉所有的锁,只是释放了代码里调用wait()的锁。


其实这篇文章的主题是个很琐碎的细节,实际中遇到的情况很少,而且直观上也能想到答案。只是现在一些教材和网络文章中,很多对比sleep和wait,只是说“sleep不释放线程持有的锁,wait释放线程持有的所锁”,wait释放锁、wait释放锁、wait释放锁...(面试要应付的知识点重复三遍?)。很多初学者仅仅记住这个答案,会导致一些误解,其实准确的来说是obj.wait()函数只释放线程持有的obj锁,而不是释放线程所有的锁,或者说wait()函数之所以是成员函数而不是静态函数,就是只和具体的实体关联(大家可以换位思考下为什么Thread.sleep()函数是静态的)。









你可能感兴趣的:(Java,多线程)