Java微服务架构师_Java 并发编程_004

最新推荐文章于 2024-04-30 08:19:59 发布

Coder_Boy_

最新推荐文章于 2024-04-30 08:19:59 发布

阅读量128

点赞数 1

分类专栏： Java架构师文章标签： 1024程序员节多线程

本文链接：https://blog.csdn.net/Coder_Boy_/article/details/109266106

版权

Java架构师专栏收录该内容

117 篇文章 3 订阅

订阅专栏

本文通过一个多线程示例展示了Java中wait()方法的使用，当一个线程调用共享对象的wait()方法时，只会释放当前对象的锁，而不会释放其他对象的锁。线程A在持有resourceA和resourceB锁的情况下调用wait()，只会释放resourceA，导致线程B能获取到resourceA的锁，但无法获取resourceB的锁，从而说明了锁的局部性。

摘要由CSDN通过智能技术生成

有关锁的一些注意点
当前线程调用共享变量的wait()方法后，只会释放当前共享变量上的锁，如果当前线程还持有其他共享变量的锁，则这些锁是不会被释放的。

package com.allen.base.day02.lock;

public class MultiLockDemo {
    private static volatile Object resourceA = new Object();
    private static volatile Object resourceB = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    // 获取resourceA共享资源的监视器锁
                    synchronized (resourceA) {
                        System.out.println("threadA get resourceA lock ");
                        // h获取resourceB共享资源的监视器锁
                        synchronized (resourceB) {
                            System.out.println("threadA get resourceB lock ");
                            System.out.println("threadA release resourceA lock ");
                            // 线程A阻塞，并释放获取到的resourceA的锁
                            resourceA.wait();

                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    // 获取resourceA共享资源的监视器锁
                    synchronized (resourceA) {
                        System.out.println("threadB get resourceA lock ");
                        System.out.println("threadB try get resourceB lock... ");

                        // h获取resourceB共享资源的监视器锁
                        synchronized (resourceB) {
                            System.out.println("threadB get resourceB lock ");
                            System.out.println("threadB release resourceA lock");
                            // 线程B阻塞，并释放获取到的resourceA的锁
                            resourceA.wait();

                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        threadA.start();
        threadB.start();

        threadA.join();
        threadB.join();

        System.out.println("main thread over ");
    }

}

如上代码：

在main函数中启动了线程A 和线程B，为了让线程A
先获取到锁，这里让线程B先休眠了1s，线程A先后获取到共享变量resourceA和resourceB上的锁，然后调用了resourceA的wait()方法阻塞自己，阻塞自己后线程A释放掉获取的resourceA上的锁。
线程B休眠结束后首先尝试获取resourceA上的锁，如果当前线程A还没有调用wait方法释放该锁，那么线程B会被阻塞，但线程A释放resourceA上的锁后，线程B就会获取到resourceA上的锁，然后再尝试获取resourceB上的锁，由于线程A调用的是resourceA上的wait()方法，所有线程A挂起自己后并没有释放获取的resourceB上的锁，所有线程B尝试获取resourceB上的锁会被阻塞。
这说明了当前线程调用共享对象的wait()方法时，当前线程只会释放当前共享对象的锁，当前线程获取的其他共享对象的锁并不会被释放掉。