Java轻量级锁升级为重量级锁的原理与过程详解

// 轻量级锁获取过程示例
public class LightweightLockDemo {
    private Object lock = new Object();
    
    public void demonstrateLocking() {
        synchronized (lock) {
            // 临界区代码
            System.out.println("Thread: " + Thread.currentThread().getName() + 
                             " acquired lightweight lock");
            
            // TRAE IDE调试技巧：使用断点调试查看锁状态
            // 在TRAE IDE中设置条件断点，观察lock对象的Mark Word变化
        }
    }
}

// 模拟锁升级过程的监控代码
public class LockUpgradeMonitor {
    private static final Object lock = new Object();
    private static volatile int counter = 0;
    
    public static void main(String[] args) throws InterruptedException {
        // 创建多个线程模拟锁竞争
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    synchronized (lock) {
                        counter++;
                        
                        // 使用TRAE IDE的内存分析工具
                        // 可以观察到锁状态的实时变化
                        if (j % 100 == 0) {
                            System.out.println("Thread: " + 
                                Thread.currentThread().getName() + 
                                " - Counter: " + counter);
                        }
                    }
                }
            }).start();
        }
        
        Thread.sleep(5000);
        System.out.println("Final counter: " + counter);
    }
}

// 简化的ObjectMonitor结构（基于OpenJDK源码）
class ObjectMonitor {
private:
    volatile markOop _header;      // 对象头
    volatile void* _object;          // 关联的对象
    volatile void* _owner;           // 当前拥有锁的线程
    volatile intptr_t _recursions; // 重入次数
    volatile int _count;             // 等待线程数
    
public:
    void enter(TRAPS);               // 获取锁
    void exit(bool not_suspended);   // 释放锁
    void wait(jlong millis, bool interruptible, TRAPS);
    void notify(TRAPS);
    void notifyAll(TRAPS);
};

// 性能测试代码
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Group)
public class LockPerformanceTest {
    
    private final Object lock = new Object();
    private volatile int counter = 0;
    
    @Benchmark
    @Group("lightweight")
    public void lightweightLockTest() {
        synchronized (lock) {
            counter++;
        }
    }
    
    @Benchmark
    @Group("heavyweight")
    public void heavyweightLockTest() throws InterruptedException {
        synchronized (lock) {
            Thread.sleep(1); // 模拟长时间持有锁
            counter++;
        }
    }
}

// 优化示例：使用ConcurrentHashMap替代同步Map
public class LockOptimizationDemo {
    
    // 不推荐：重量级锁
    private final Map<String, String> syncMap = 
        Collections.synchronizedMap(new HashMap<>());
    
    // 推荐：分段锁优化
    private final Map<String, String> concurrentMap = 
        new ConcurrentHashMap<>();
    
    public void demonstrateOptimization() {
        // 使用TRAE IDE的性能分析工具
        // 可以清晰看到锁竞争情况的变化
        
        long start1 = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            synchronized (syncMap) {
                syncMap.put("key" + i, "value" + i);
            }
        }
        long time1 = System.nanoTime() - start1;
        
        long start2 = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            concurrentMap.put("key" + i, "value" + i);
        }
        long time2 = System.nanoTime() - start2;
        
        System.out.println("SynchronizedMap time: " + time1 + "ns");
        System.out.println("ConcurrentHashMap time: " + time2 + "ns");
        System.out.println("Performance improvement: " + 
                         (time1 - time2) * 100.0 / time1 + "%");
    }
}

# 监控锁升级情况
-XX:+PrintGCDetails
-XX:+PrintGCApplicationStoppedTime
-XX:+PrintConcurrentLocks
-XX:+PrintInlining
 
# 偏向锁相关参数
-XX:+UseBiasedLocking
-XX:BiasedLockingStartupDelay=0
 
# 自旋锁参数
-XX:PreBlockSpin=10
-XX:+UseSpinning

// 使用JMX监控锁状态
public class LockMonitor {
    
    public static void printLockStatistics() {
        // 获取线程MXBean
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        
        if (threadBean.isObjectMonitorUsageSupported()) {
            long[] threadIds = threadBean.getAllThreadIds();
            ThreadInfo[] threadInfos = threadBean.getThreadInfo(
                threadIds, true, true);
            
            for (ThreadInfo info : threadInfos) {
                if (info != null) {
                    MonitorInfo[] monitors = info.getLockedMonitors();
                    System.out.println("Thread: " + info.getThreadName());
                    
                    for (MonitorInfo monitor : monitors) {
                        System.out.println("  Locked: " + 
                            monitor.getLockedStackFrame());
                    }
                }
            }
        }
    }
    
    public static void main(String[] args) {
        // 在TRAE IDE中运行此代码
        // 结合IDE的可视化工具，可以直观地看到锁的分布情况
        printLockStatistics();
    }
}

// 自定义锁性能监控器
public class LockPerformanceMonitor {
    private static final ConcurrentHashMap<String, AtomicLong> 
        lockStats = new ConcurrentHashMap<>();
    
    public static void recordLockAcquisition(String lockName, 
                                           long waitTime) {
        lockStats.computeIfAbsent(lockName + "_waits", 
            k -> new AtomicLong()).incrementAndGet();
        lockStats.computeIfAbsent(lockName + "_total_wait", 
            k -> new AtomicLong()).addAndGet(waitTime);
    }
    
    public static void printStatistics() {
        lockStats.forEach((key, value) -> 
            System.out.println(key + ": " + value.get()));
    }
}