java中的内置锁, 多个synchronized方法会相互阻塞

volming36337

已于 2024-09-30 11:33:18 修改

阅读量226

点赞数 8

分类专栏： Java基础文章标签： java jvm java-ee

于 2024-09-30 11:29:14 首次发布

本文链接：https://blog.csdn.net/volming36337/article/details/142652216

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

多个synchronized修饰的方法会相互阻塞

内置锁

        在Java中，每个对象都有一个内置锁，也称为监视器锁。

        内置锁是一种互斥锁，只能被一个线程获得。

        当一个线程获取了一个对象的内置锁，其他线程就不能访问这个对象的同步方法或同步代码块，直到锁被释放。

synchronized

java中的2种对象

Java有两种对象：Object实例对象和Class对象。

类锁

使用synchronized关键字修饰static静态方法时，因为静态方法属于Class实例而不是单个Object实例，所以synchronized的同步锁并不是普通Object对象的监视器锁，而是类所对应的Class对象的监视器锁，即类锁。

对象锁

使用被synchronized修饰的普通方法或普通代码块的时候，synchronized的同步锁是当前对象this的监视器锁，即对象锁。

多个synchronized修饰的方法会相互阻塞

在 Java 中，如果一个类中有多个被synchronized修饰的方法，那么当一个线程进入其中一个synchronized方法时，其他线程在尝试进入任何synchronized方法时都会被阻塞。

因为在 Java 中，对象的synchronized方法使用的是对象内部的同一把锁（也称为监视器锁）。当一个线程获得了这个对象的锁并进入一个synchronized方法后，其他线程如果想要进入该对象的任何synchronized方法，都必须等待当前持有锁的线程释放锁。

public class SyncTest {

    synchronized void sync1() {
        System.out.println(" 。。。 sync1 start 。。。 ");
        ThreadUtil.sleepSeconds(5);
        System.out.println(" 。。。 sync1 end 。。。 ");
    }

    synchronized void sync2() {
        System.out.println(" 。。。 sync2  start 。。。 ");
        ThreadUtil.sleepSeconds(2);
        System.out.println(" 。。。 sync2 end 。。。 ");
    }

    public static void main(String[] args) {
        SyncTest syncTest = new SyncTest();
        new Thread(() -> {
            for (; ; ) {
                syncTest.sync1();
            }
        }).start();

        new Thread(() -> {
            for (; ; ) {
                syncTest.sync2();
            }
        }).start();
        ThreadUtil.sleepSeconds(1000);
    }

}