随着多核处理器的普及，现代应用越来越依赖并发编程来提升性能和响应速度。Java作为主流编程语言，自然也内建了丰富的并发支持。但在并发环境下，最常见的坑往往来自于线程安全问题。本文将结合实际开发经验，聊聊Java并发编程中保证线程安全的关键技术——锁机制。

线程安全为何如此重要？

线程安全的核心是：多个线程访问同一共享资源时，不会导致数据不一致或程序异常。比如，多个线程同时修改一个变量，如果不加控制，可能出现“读写冲突”，导致结果出错。

举个简单例子：

public class Counter {
    private int count = 0;

    public void increment() {
        count++;  // 不是原子操作
    }

    public int getCount() {
        return count;
    }
}

如果多个线程同时调用 increment()，可能出现计数结果小于预期，因为 count++ 实际上是读、加一、写的三步操作，容易产生竞态条件。

Java中的锁机制

为了解决上述问题，Java提供了多种锁机制。

1、synchronized关键字

synchronized 是Java最基础的锁，作用于代码块或者方法，确保同一时刻只有一个线程执行被锁住的代码。

public synchronized void increment() {
    count++;
}

优点：

• 使用简单，语法直接。
• JVM底层优化较好，性能较为均衡。

缺点：

• 粒度较粗，容易导致线程阻塞。
• 不灵活，比如无法中断等待锁的线程。

2、显式锁Lock接口

java.util.concurrent.locks.Lock 提供了更灵活的锁控制，比如：

• 可响应中断的锁等待
• 非阻塞尝试获取锁
• 超时获取锁

示例：

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

使用显式锁需要手动释放锁，比较考验程序员细心程度，但带来了更强的控制能力。

3、原子变量

对于简单的数值计数，java.util.concurrent.atomic 包下的原子类（如 AtomicInteger）通过底层的CAS操作，实现了无锁的线程安全。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

这种方式性能更优，且避免了锁竞争，但只适合特定场景。

选对锁，避免死锁

锁机制带来了便利，但也有风险，比如死锁——两个线程互相等待对方释放锁，程序陷入僵局。

避免死锁的关键点：

• 统一锁获取顺序。
• 尽量减少持锁时间。
• 避免在持锁期间调用可能阻塞的操作。

结语

Java并发编程是一把双刃剑，合理使用锁可以保证线程安全，提升程序健壮性；但不当使用则可能导致性能下降甚至死锁。理解锁的原理和场景，结合业务需求灵活选择，是每个Java开发者的必修课。

希望这篇文章能帮助你在并发编程的路上少踩坑，多走稳。