Java并发编程: 深入理解Monitor机制与锁优化

daweias

于 2024-11-27 17:29:09 发布

阅读量1.8k

点赞数 33

分类专栏： Java多线程文章标签： java 开发语言后端

本文链接：https://blog.youkuaiyun.com/daweias/article/details/144090349

版权

Java多线程专栏收录该内容

44 篇文章

订阅专栏

Java并发编程: 深入理解Monitor机制与锁优化

引言

在Java并发编程中，Monitor（监视器）机制是一个核心的同步工具。本文将深入探讨Monitor的实现原理、锁优化策略以及实际应用场景，帮助读者全面理解Java中的线程同步机制。

Monitor的基本概念

Monitor可以理解为一个同步工具包，它将对共享资源的所有访问都封装起来，确保在任何时刻最多只有一个线程能够访问被保护的资源。从实现角度看，Monitor包含以下核心组件：

Monitor的核心结构

class ObjectMonitor {
    private Object _object;         // 被锁定的对象
    private Thread _owner;          // 当前持有锁的线程
    private Queue<Thread> _WaitSet; // 等待集合
    private Queue<Thread> _EntryList; // 竞争集合
    private int _recursions;        // 重入计数
}

每个Java对象都与一个Monitor关联。当使用synchronized关键字时，就是在操作对象的Monitor：

public class SynchronizationExample {
    private final Object lock = new Object();
    
    public void synchronizedMethod() {
        synchronized(lock) {
            // 这段代码在执行时获取了lock对象的Monitor
            performTask();
        }
    }
}

锁的实现机制

对象头与Mark Word

在HotSpot虚拟机中，对象头包含两部分信息：Mark Word和类型指针。Mark Word用于存储对象的运行时数据，如哈希码、GC分代年龄、锁状态标志等。

不同状态下Mark Word的存储内容：

锁状态	存储内容
无锁	对象哈希码、分代年龄、是否偏向锁(0)、锁标志位(01)
偏向锁	线程ID、偏向时间戳、分代年龄、是否偏向锁(1)、锁标志位(01)
轻量级锁	指向栈中锁记录的指针、锁标志位(00)
重量级锁	指向互斥量（重量级锁）的指针、锁标志位(10)

锁的升级过程

Java SE 1.6引入了锁升级的概念，也就是锁可以从偏向锁逐步升级到轻量级锁，最后升级到重量级锁。这个过程是不可逆的。

1. 偏向锁

偏向锁是针对于一个线程多次申请同一个锁来做出的优化。当一个线程访问同步块时，会在对象头中存储该线程的ID：

class BiasedLocking {
    private static void runWithBiasedLock(Object lock) {
        // 第一次获取锁时，记录线程ID
        synchronized(lock) {
            // 再次进入时，只需要比对线程ID，不需要CAS操作
            performTask();
        }
    }
}

2. 轻量级锁

当发生第一次锁竞争时，偏向锁就会升级为轻量级锁。轻量级锁采用CAS操作来获取锁：

class LightweightLocking {
    private static void acquireLightweightLock(Object lock) {
        // 在当前线程的栈帧中创建锁记录（Lock Record）
        LockRecord lockRecord = createLockRecord(lock);
        
        // 使用CAS操作将对象头中的Mark Word替换为指向Lock Record的指针
        if (casMarkWord(lock, lockRecord)) {
            // 获取锁成功
        } else {
            // 获取锁失败，升级为重量级锁
            inflateToHeavyweight(lock);
        }
    }
}

3. 重量级锁

当轻量级锁的自旋次数超过阈值或多个线程竞争时，锁就会升级为重量级锁：

class HeavyweightLocking {
    private final Object lock = new Object();
    
    public void complexOperation() {
        synchronized(lock) {
            // 此时使用操作系统层面的互斥量
            // 线程阻塞和唤醒都需要操作系统介入
            performComplexTask();
        }
    }
}

线程等待与唤醒机制

等待队列管理

Monitor维护了两个队列：_WaitSet和_EntryList。这两个队列的作用不同：

_WaitSet：存放调用了wait()方法的线程
_EntryList：存放等待获取锁的线程

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;
    
    public void waitForCondition() {
        synchronized(lock) {
            while(!condition) {
                try {
                    lock.wait(); // 线程进入_WaitSet
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
    
    public void notifyCondition() {
        synchronized(lock) {
            condition = true;
            lock.notify(); // 从_WaitSet中唤醒一个线程
        }
    }
}

notify()与notifyAll()的选择

在设计并发程序时，需要谨慎选择使用notify()还是notifyAll()：

public class NotificationStrategy {
    private final Object lock = new Object();
    private Queue<Task> tasks = new LinkedList<>();
    
    // 单一消费者模式：使用notify()
    public void addTask(Task task) {
        synchronized(lock) {
            tasks.offer(task);
            lock.notify(); // 只需要唤醒一个消费者
        }
    }
    
    // 条件变化影响所有等待线程：使用notifyAll()
    public void shutdownAll() {
        synchronized(lock) {
            isShutdown = true;
            lock.notifyAll(); // 需要通知所有等待的线程
        }
    }
}

自旋锁优化

自旋锁是一种等待锁的方式，当前线程不会立即阻塞，而是执行一个忙循环（自旋）：

public class SpinLockExample {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    private int spinCount = 0;
    
    public void lock() {
        Thread current = Thread.currentThread();
        // 自旋等待
        while (!owner.compareAndSet(null, current)) {
            spinCount++;
            if (spinCount > SPIN_LIMIT) {
                // 超过自旋次数，转为传统的阻塞锁
                blockThread();
                return;
            }
            // 使用CPU提供的pause指令
            Thread.onSpinWait();
        }
    }
}

自适应自旋

JVM采用自适应自旋，根据上次自旋的成功与否来动态调整自旋的时间：

class AdaptiveSpinning {
    private static int calculateSpinTime() {
        if (lastSpinSucceeded && ownerRunning) {
            return previousSpinTime * 2;
        } else {
            return previousSpinTime / 2;
        }
    }
}

实际应用建议

选择合适的锁实现：

public class LockSelection {
    // 简单同步场景：使用synchronized
    public synchronized void simpleOperation() {
        // 简单的原子操作
    }
    
    // 复杂同步场景：使用ReentrantLock
    private final ReentrantLock lock = new ReentrantLock();
    public void complexOperation() {
        lock.lock();
        try {
            // 需要灵活控制的同步操作
        } finally {
            lock.unlock();
        }
    }
}

最小化同步范围：

public class SynchronizationScope {
    // 不好的实践
    public synchronized void badPractice() {
        // 较长时间的操作
        heavyOperation();
    }
    
    // 好的实践
    public void goodPractice() {
        // 非同步的操作
        Object result = prepareData();
        
        synchronized(this) {
            // 最小化同步范围
            updateSharedState(result);
        }
    }
}