基于锁的获取与释放方式即计划于所得获取与释放方式进行分类——显式锁和隐式锁

隐式锁

Java中的隐式锁（也称为内置锁或自动锁）是通过使用关键字实现的一种线程同步机制。当一个线程进入被synchronized修饰的方法或代码块时，它会自动获得对象级别的锁，退出该方法或代码块时则会自动释放这把锁。

在Java中，隐式锁的实现机制主要包括以下两种类型：

• 互斥锁（Mutex） 

虽然Java标准库并未直接暴露操作系统的互斥锁提供使用，但在Java虚拟机对synchronized关键字处理的底层实现中，当锁竞争激烈且必须升级为重量级锁时，会利用操作系统的互斥量机制来确保在同一时刻仅允许一个线程持有锁，从而实现严格的线程互斥控制。

• 内部锁（Intrinsinc Lock）或监视器锁（Monitor Lock）

Java语言为每个对象内建了一个监视器锁，这是一个更高级别的抽象。我们可以通过使用synchronized关键字即可便捷地管理和操作这些锁。当一个线程访问被synchronized修饰的方法或代码块时，会自动获取相应对象的监视器锁，并在执行完毕后自动释放，这一过程对用户透明，故被称为隐式锁。每个Java对象均与一个监视器锁关联，以此来协调对该对象状态访问的并发控制。 

应用场景分为：

• 实例方法同步：锁是当前实例对象。
• 静态方法同步：锁是当前类的Class对象。
• 同步代码块（使用对象实例作为锁）。
• 同步代码块（使用类的Class对象作为锁）

场景1： 对象状态保护（账户余额操作）

public class BankAccount {
    private double balance; // 共享资源

    // 隐式锁保护存款操作（锁为当前对象实例）
    public synchronized void deposit(double amount) {
        balance += amount;
        System.out.println("存款: +" + amount + " | 余额: " + balance);
    }

    // 隐式锁保护取款操作
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("取款: -" + amount + " | 余额: " + balance);
        } else {
            System.out.println("取款失败！余额不足");
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        // 多线程并发操作账户
        new Thread(() -> account.deposit(100)).start();
        new Thread(() -> account.withdraw(50)).start();
        new Thread(() -> account.withdraw(70)).start();
    }
}

输出结果：

存款: +100.0 | 余额: 100.0
取款: -50.0 | 余额: 50.0
取款失败！余额不足 

说明：

• synchronized方法保证同一时间只有一个线程能操作balance。
• 自动处理锁的获取/释放，避免余额不一致。

---

 场景2：静态方法锁（类级别锁）

public class IdGenerator {
    private static int counter = 0;

    // 静态方法锁（锁为Class对象）
    public static synchronized int generateId() {
        return ++counter;
    }

    public static void main(String[] args) {
        // 多线程调用静态方法
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                int id = IdGenerator.generateId();
                System.out.println(Thread.currentThread().getName() + " : " + id);
            }).start();
        }
    }
}

输出结果：顺序可能不同，但ID不重复

Thread-0 : 1
Thread-2 : 3
Thread-1 : 2
...

说明：

• 静态方法锁保护类级别的共享变量counter。
• 锁对象是IdGenerator.class，所有实例共享同一把锁。

对于静态方法锁（类级别锁）典型应用场景全局唯一ID生成器，单例模式实现（线程安全版），全局配置管理，跨实例的共享资源控制

全局唯一ID生成器

• 场景：多线程环境下生成不重复的订单号、用户ID等
• 问题：普通对象锁无法保护静态计数器
• 解决方案：类锁保护静态变量

public class OrderIdGenerator {
    private static int counter = 0;

    // 类级别锁保护
    public static synchronized String generateId() {
        return "ORD-" + System.currentTimeMillis() + "-" + (++counter);
    }
}

// 多线程安全调用
IntStream.range(0, 10).forEach(i -> 
    new Thread(() -> {
        System.out.println(OrderIdGenerator.generateId());
    }).start()
);

单例模式实现（线程安全版）

• 场景：延迟初始化重量级资源（数据库连接池、配置加载）
• 问题：双重检查锁需配合类锁使用

public class DatabasePool {
    private static volatile DatabasePool instance;

    // 私有构造方法
    private DatabasePool() { /* 初始化连接池 */ }

    // 类锁保护实例创建
    public static DatabasePool getInstance() {
        if (instance == null) {
            synchronized (DatabasePool.class) { // 类级别锁
                if (instance == null) {
                    instance = new DatabasePool();
                }
            }
        }
        return instance;
    }
}

 全局配置管理

• 场景：多线程加载/刷新应用配置
• 问题：配置需保证全局一致性

public class AppConfig {
    private static Properties config;

    // 类锁保护配置加载
    public static synchronized void reloadConfig() {
        Properties newConfig = new Properties();
        try (InputStream is = new FileInputStream("config.properties")) {
            newConfig.load(is);
            config = newConfig; // 原子性更新
        }
    }

    // 读操作无需同步（final字段可见性保证）
    public static String get(String key) {
        return config.getProperty(key);
    }
}

跨实例的共享资源控制

• 场景：限制整个类的某个行为（如全局限流）
• 问题：需要跨对象实例协同

public class RateLimiter {
    private static int requestCount = 0;
    private static final int MAX_REQUESTS = 100;

    // 类锁保护全局计数器
    public static synchronized boolean allowRequest() {
        if (requestCount >= MAX_REQUESTS) {
            return false;
        }
        requestCount++;
        return true;
    }

    public static synchronized void releaseRequest() {
        requestCount--;
    }
}

---

场景3：同步代码块（减小细粒度）

public class Cache {
    private final Object lock = new Object(); // 专用锁对象
    private Map data = new HashMap<>();

    public void update(String key, String value) {
        // 非同步操作（无竞争）
        System.out.println("预处理...");

        // 仅同步共享资源操作
        synchronized (lock) {
            data.put(key, value);
            System.out.println("更新: " + key + "=" + value);
        }
    }

    public String get(String key) {
        synchronized (lock) {
            return data.get(key);
        }
    }
}

 对于同步代码块（减小细粒度）典型应用场景，缓存系统（读写分离），订单状态变更（局部同步），连接池管理（减少锁范围），批量处理（分段加锁）

缓存系统（读写分离）

• 场景：缓存需要高频读写，但只有写操作需要同步
• 问题：直接锁整个方法会导致读操作也被阻塞
• 优化：用同步块只保护写操作

public class CacheSystem {
    private final Map cache = new HashMap<>();
    private final Object lock = new Object(); // 专用锁对象

    // 读操作（不加锁）
    public String get(String key) {
        return cache.get(key); 
    }

    // 写操作（仅同步必要部分）
    public void update(String key, String value) {
        // 非同步预处理（如参数校验）
        if (key == null) throw new IllegalArgumentException();

        synchronized (lock) { // 只锁核心逻辑
            cache.put(key, value);
            System.out.println("Updated: " + key);
        }
    }
}

订单状态变更（局部同步）

• 场景：订单状态变更需保证原子性，但其他操作（如日志记录）无需同步
• 问题：锁整个方法会导致无关操作阻塞
• 优化：只同步状态变更部分

public class OrderService {
    private Order currentOrder;

    public void processOrder(Order newOrder) {
        // 非关键操作（如日志）
        log("Processing order: " + newOrder.getId());

        // 仅同步状态变更
        synchronized (this) {
            if (currentOrder == null) {
                currentOrder = newOrder;
                updateDatabase(newOrder); // 关键操作
            }
        }
    }

    private void log(String message) { /* 非同步操作 */ }
}

连接池管理（减少锁范围）

• 场景：获取连接时需要同步，但连接使用过程无需锁
• 问题：锁整个getConnection()方法会导致连接使用期间也持有锁
• 优化：仅同步连接分配逻辑

public class ConnectionPool {
    private final LinkedList pool = new LinkedList<>();
    private final Object poolLock = new Object();

    public Connection getConnection() throws SQLException {
        Connection conn;
        synchronized (poolLock) { // 仅同步分配过程
            if (pool.isEmpty()) {
                conn = createNewConnection();
            } else {
                conn = pool.removeFirst();
            }
        }
        
        // 连接初始化（非同步操作）
        conn.setAutoCommit(true);
        return conn;
    }
}

批量处理（分段加锁）

• 场景：批量处理集合数据时，不同元素可独立处理
• 问题：锁整个集合会导致并行度下降
• 优化：按元素分段加锁

public class BatchProcessor {
    private final List