Java锁机制深度解析：从重量级到智能升级

public class InventorySystem {
    private int stock = 100;
    
    public synchronized boolean reduceStock(int quantity) {
        if (stock >= quantity) {
            try {
                Thread.sleep(10); // 模拟业务处理时间
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            stock -= quantity;
            return true;
        }
        return false;
    }
}

public class OrderProcessor {
    private final List<Order> orders = new ArrayList<>();
    
    // 锁粒度过粗的示例：整个方法被锁定
    public synchronized void processOrder(Order order) {
        validateOrder(order);      // 验证订单（可并行）
        deductInventory(order);    // 扣减库存（需同步）
        updateUserAccount(order);  // 更新账户（可并行）
        sendNotification(order);   // 发送通知（可并行）
    }
}

public class DeadlockExample {
    private final Object lockA = new Object();
    private final Object lockB = new Object();
    
    public void method1() {
        synchronized (lockA) {
            synchronized (lockB) { // 可能死锁点
                // 业务逻辑
            }
        }
    }
    
    public void method2() {
        synchronized (lockB) {
            synchronized (lockA) { // 可能死锁点
                // 业务逻辑
            }
        }
    }
}

public class BiasedLockExample {
    private final Object lock = new Object();
    private int counter = 0;
    
    public void increment() {
        // 同一线程多次调用时，偏向锁生效
        synchronized(lock) {
            counter++;
            if (counter % 100 == 0) {
                // 调用hashCode会撤销偏向锁
                System.out.println("Lock hash: " + lock.hashCode());
            }
        }
    }
}

public class LightweightLockExample {
    private final Object resource = new Object();
    
    public void accessResource() {
        // 低竞争时使用轻量级锁
        synchronized(resource) {
            // 快速操作，适合自旋等待
            performQuickOperation();
        }
    }
    
    public void performQuickOperation() {
        // 执行时间短的操作
    }
}

public class LockCoarseningExample {
    private final Object lock = new Object();
    
    public void processItems(List<Item> items) {
        // 原始代码：循环内多次加锁解锁
        for (Item item : items) {
            synchronized(lock) {  // JIT可能将此锁粗化到循环外部
                processItem(item);
            }
        }
    }
    
    // 优化后逻辑相当于：
    public void processItemsOptimized(List<Item> items) {
        synchronized(lock) {  // 锁被粗化到循环外部
            for (Item item : items) {
                processItem(item);
            }
        }
    }
}

public class LockEliminationExample {
    // 示例1：局部StringBuffer的锁消除
    public String createMessage() {
        // StringBuffer内部方法是同步的
        StringBuffer sb = new StringBuffer();  // sb不逃逸
        sb.append("Hello, ");
        sb.append("World!");
        // JIT会消除sb.append()中的锁操作
        return sb.toString();
    }
    
    // 示例2：同步局部对象的锁消除
    public int computeSum() {
        Object localLock = new Object();  // 局部锁对象
        int sum = 0;
        synchronized(localLock) {  // 此锁可被消除
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
        }
        return sum;
    }
}

public class ExplicitLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int sharedCounter = 0;
    
    public void increment() {
        lock.lock();  // 显式获取锁
        try {
            sharedCounter++;
        } finally {
            lock.unlock();  // 必须显式释放
        }
    }
    
    // 尝试获取锁（避免死锁）
    public boolean tryIncrement() {
        if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                sharedCounter++;
                return true;
            } finally {
                lock.unlock();
            }
        }
        return false;
    }
}

public class ReadWriteLockExample {
    private final Map<String, Object> cache = new HashMap<>();
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    public Object get(String key) {
        rwLock.readLock().lock();  // 获取读锁
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }
    
    public void put(String key, Object value) {
        rwLock.writeLock().lock();  // 获取写锁
        try {
            cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

public class LockFreeCounter {
    private final AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        int current;
        do {
            current = counter.get();  // 读取当前值
        } while (!counter.compareAndSet(current, current + 1));  // CAS更新
    }
}

// 基于Redis的分布式锁示例
public class DistributedLock {
    private final Jedis jedis;
    
    public boolean tryLock(String key, String value, int expireSeconds) {
        // SET key value NX EX expireSeconds
        String result = jedis.set(key, value, "NX", "EX", expireSeconds);
        return "OK".equals(result);
    }
    
    public void unlock(String key, String value) {
        // Lua脚本保证原子性：只有值匹配才删除
        String script = 
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "    return redis.call('del', KEYS[1]) " +
            "else " +
            "    return 0 " +
            "end";
        jedis.eval(script, 1, key, value);
    }
}

// 自适应锁策略的伪代码示例
public class AdaptiveLock {
    private LockStrategy currentStrategy = LockStrategy.LIGHTWEIGHT;
    private int contentionCount = 0;
    
    public void lock() {
        if (currentStrategy == LockStrategy.LIGHTWEIGHT && contentionCount > THRESHOLD) {
            currentStrategy = LockStrategy.HEAVYWEIGHT;
        }
        currentStrategy.acquire();
    }
    
    public void unlock() {
        currentStrategy.release();
        // 更新竞争统计数据
    }
}