类锁和对象锁

本文深入探讨了Java中的对象锁和类锁的概念及实现方式。通过具体示例代码演示了synchronized关键字如何应用于方法和代码块来实现不同类型的锁,解释了它们之间的区别,并展示了线程间的同步与异步行为。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1、对象锁(synchronized修饰方法或代码块),分两种情况,一种是synchronized method和synchronized(this)代码块,锁定的都是当前对象,两者是同一把锁,一种是synchronized(任意Object对象),代码如下:

public class ObjectLock {
public void method1(){
synchronized (this) { //对象锁
try {
System.out.println("start method1..");
Thread.sleep(2000);
System.out.println("end method1..");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public synchronized void method2(){
try {
System.out.println("start method2 ..");
Thread.sleep(2000);
System.out.println("end method2 ..");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

private Object lock = new Object();
public void method3(){ //任何对象锁
synchronized (lock) {
try {
System.out.println("start method3..");
Thread.sleep(2000);
System.out.println("end method3..");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}


public static void main(String[] args) {

final ObjectLock objLock = new ObjectLock();

Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method1();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method3();
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
objLock.method2();
}
});

t1.start();
t2.start();
t3.start();
}

}

t1和t2线程争抢的是同一把锁,t1访问method1之后释放当前锁,t2才可以访问method2,而t3访问的method3使用的是另外一把自定义的对象锁,所以,t1和t2同步,和t3异步。

输出结果 为:

start method3..
start method1..
end method3..
end method1..
start method2 ..
end method2 ..


2、类锁(synchronized 修饰静态的方法或代码块)

于一个class不论被实例化多少次,其中的静态方法和静态变量在内存中都只有一份。所以,一旦一个静态的方法被申明为synchronized。此类所有的实例化对象在调用此方法,共用同一把锁,称之为类锁。

java类可能会有多个对象,但是只有1个Class对象,也就是说类的不同实例之间共享该类的Class对象。Class对象其实也仅仅是1个java对象,只不过有点特殊而已。由于每个java对象都有1个互斥锁,而类的静态方法是需要Class对象。所以所谓的类锁,不过是Class对象的锁而已。获取类的Class对象有好几种,synchronized(类名.class)的方式

public class Test 

   // 类锁:形式1 
public static synchronized void Method1() 

System.out.println("我是类锁一号"); 
try 

Thread.sleep(500); 
} catch (InterruptedException e) 

e.printStackTrace(); 

}

}

// 类锁:形式2
public void Method2()
{
    synchronized (Test.class)
    {
        System.out.println("我是类锁二号");
        try
        {
            Thread.sleep(500);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}


<think>好的,我现在需要帮助用户理解Java中重量级如何创建Monitor对象。首先,我得回忆一下相关的知识点。用户提到了引用[1]、[2]、[3],里面涉及Java对象头、Monitor的概念以及synchronized的原理。 首先,Monitor对象是在使用synchronized对对象上时创建的。但具体什么时候创建呢?是不是每次加都会新建一个Monitor?应该不是,因为引用里提到每个Java对象都有一个对应的Monitor,可能是在需要时才创建。比如,当对象第一次被作为使用时,JVM会为它生成Monitor实例。 然后,Java对象头中的Mark Word存储了指向Monitor的指针。在轻量级的时候可能没有Monitor,升级到重量级时才会生成。这里需要考虑升级的过程:偏向->轻量级->重量级。当发生竞争时,会升级到重量级,此时才会创建Monitor对象。 接下来,创建Monitor的机制是怎样的?可能由C++实现的ObjectMonitor结构体,JVM在内部管理这些Monitor。当对象需要进入重量级时,JVM检查是否已经存在对应的Monitor,如果没有,则创建一个并关联到对象头。 还要考虑内存分配的问题。Monitor对象可能存放在堆内存还是其他区域?根据引用,应该是由JVM在堆中分配,因为它是与Java对象关联的,但具体实现可能依赖于JVM版本。 最后,需要确认用户的问题:重量级下Monitor对象的创建机制。总结一下步骤:对象首次作为进入重量级状态时,JVM创建Monitor,并让Mark Word指向它。之后同一对象的操作都通过这个Monitor进行同步。 可能还需要提到Monitor的结构,比如拥有entry set、wait set、owner等,但用户主要问的是创建机制,所以重点放在何时创建以及如何关联到对象头。 需要确保回答覆盖以下几点: 1. Monitor对象的创建时机:首次进入重量级时。 2. 如何与Java对象关联:通过对象头的Mark Word指针。 3. JVM内部的管理机制,比如ObjectMonitor内存分配。 4. 升级过程的影响。 这样用户就能理解整个过程了。</think>### 重量级中 Monitor 对象的创建机制 在Java中,当使用 `synchronized` 关键字对对象加时,如果升级为**重量级**(即处于竞争激烈的场景),JVM 会为该对象创建一个关联的 Monitor 对象。以下是具体的创建机制流程: --- #### 1. **Java 对象头与 Monitor 的关联** - 每个 Java 对象在内存中分为三部分:**对象头**、实例数据对齐填充。 - **对象头**中的 **Mark Word** 字段(通常占用 32/64 位)存储了对象的状态信息。当升级为重量级时,Mark Word 会被替换为一个指向 **Monitor 对象**的指针[^1][^3]。 --- #### 2. **Monitor 对象的创建时机** - **首次进入重量级时**:当线程尝试获取对象的,但发现存在竞争(例如已由其他线程持有),JVM 会触发升级(从偏向/轻量级升级到重量级)。 - **创建过程**:JVM 会为当前对象在堆内存中分配一个 **ObjectMonitor** 结构体(C++实现),并将对象的 Mark Word 修改为指向该 Monitor 对象的指针[^2][^3]。 --- #### 3. **Monitor 对象的结构** Monitor 对象(即 `ObjectMonitor`)包含以下核心字段: - **_owner**:指向持有的线程。 - **_EntryList**:存储等待的线程集合。 - **_WaitSet**:存储调用 `wait()` 方法后进入等待状态的线程集合。 - **_recursions**:记录的重入次数。 --- #### 4. **JVM 对 Monitor 的管理** - **全局管理**:所有 Monitor 对象由 JVM 统一管理,通过 `ObjectMonitor` 的指针与 Java 对象关联。 - **懒加载机制**:Monitor 对象并非在对象创建时生成,而是**延迟到首次需要重量级时创建**,以减少内存开销。 --- #### 5. **升级与 Monitor 的关系** 1. **无状态**:对象未关联 Monitor。 2. **偏向/轻量级**:仅通过 Mark Word 存储线程ID或栈帧记录,无需 Monitor。 3. **重量级**:触发竞争时,JVM 创建 Monitor 对象,并通过原子操作将 Mark Word 替换为 Monitor 指针,完成升级。 --- #### 示例流程 ```plaintext 线程A尝试获取处于无竞争状态 → 轻量级(Mark Word记录栈帧记录) 线程B尝试竞争 → 触发膨胀 → JVM创建Monitor对象 → Mark Word指向Monitor → 线程A/B通过Monitor同步 ``` --- ### 相关问题 1. 升级过程中,Mark Word 的变化如何保证线程安全? 2. Monitor 对象的内存分配是否会影响性能? 3. 如何通过工具观察 Java 对象的 Monitor 状态? --- 通过上述机制,Java 的重量级实现了高效的线程同步,但同时也引入了上下文切换的开销,因此在高并发场景中需谨慎使用[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值