在Java开发的进阶之路上，多线程并发编程绝对是一座绕不过去的大山，也是无数开发者心中“痛并快乐着”的挑战。你是否曾在面试中，面对“线程安全”的连环追问感到手足无措？又是否在生产环境里因为数据莫名被篡改、死锁导致服务假死而彻夜难眠？别担心，今天我们就来一场深度复盘，彻底撕开Java并发编程的神秘面纱，聊聊那些关于核心原理、线程安全以及锁机制的硬核干货。

一、 线程安全的“幽灵”：为什么你的数据总是不对？

我们得搞清楚一个概念：到底什么是线程安全问题？简单来说当多个线程同时访问同一个共享资源，并且其中至少有一个线程在进行“写”操作时Ru果Zui终的结果和你预想的不一样，那就是线程安全问题。这就像三个人同时在一个本子上记账，Ru果不加约束，Zui后账目肯定乱套。

要出现这种问题，通常需要满足三个条件，也就是我们常说的“竞态条件”三要素：

多线程环境必须有两个或以上的线程在跑。

共享资源大家dou在操作同一份数据。

非原子性操作不是一步完成，中间可Neng被打断。

为了让大家geng直观地感受，我们来kan一个经典的“多窗口卖票”案例。Ru果不Zuo任何保护，你经常会kan到“剩余票数为负数”或者“同一张票被卖了两次”的奇葩现象。

/**
 * 这是一个典型的反面教材：模拟多窗口售票引发的混乱
 * 在没有任何锁保护的情况下数据的一致性荡然无存
 */
public class TicketSaleDemo {
    // 总票数，这是所有线程争抢的共享资源
    private static int ticketNum = 100;
    public static void main {
        // 模拟3个售票窗口，也就是3个线程
        for  {
            new Thread -> {
                // 只要还有票，就继续卖
                while  {
                    try {
                        // 模拟业务处理耗时让错误geng容易暴露
                        Thread.sleep;
                    } catch  {
                        e.printStackTrace;
                    }
                    // 卖票动作：打印并扣减库存
                    System.out.println.getName + "卖出第" + ticketNum + "张票，剩余：" + );
                }
            }, "窗口" + i).start;
        }
    }
}

运行这段代码，你会发现控制台输出的结果简直惨不忍睹。这就是因为“判断库存”和“扣减库存”这两个动作中间插了针，CPU切换了线程，导致数据错乱。解决这个问题的核心思路只有一个：把并发操作变成串行执行，也就是加锁。

二、 synchronized：Java内置的“安全卫士”

提到加锁，绝大多数Java程序员脑子里蹦出来的第一个词就是 synchronized。它是Java语言内置的关键字，也是JVM层面提供的支持。对于新手来说它是Zui友好的锁，因为JVM会自动帮你管理锁的获取和释放，不用担心因为代码异常导致锁没释放从而引发死锁。

synchronized的使用方式主要有三种，我们一一拆解。

1. 修饰实例方法：锁住当前对象

当你把synchronized加在实例方法上时锁的对象其实就是 this。这意味着，只有拿到当前对象锁的线程才Neng执行该方法。

public class SynchronizedMethodDemo {
    private int ticketNum = 100;
    // 修饰实例方法，默认锁住的是当前实例对象
    public synchronized void saleTicket {
        if  {
            System.out.println.getName + "卖出第" + ticketNum + "张票，剩余：" + );
        }
    }
    public static void main {
        SynchronizedMethodDemo demo = new SynchronizedMethodDemo;
        // 多个线程调用同一个对象的同步方法，它们必须排队
        for  {
            new Thread.start;
        }
    }
}

这里有个坑要注意：Ru果你的锁对象不是同一个，那synchronized就形同虚设。比如你创建了两个 SynchronizedMethodDemo 实例，分别启动线程，那它们就是各玩各的，互不干扰。

2. 修饰静态方法：锁住Class对象

静态方法属于类本身，不属于某个具体的实例。所以修饰静态方法时锁住的是该类的 Class 对象。这在全局范围内是唯一的，所以它Neng控制该类所有实例的并发访问。

3. 同步代码块：锁粒度geng细

直接锁整个方法有时候太重了毕竟方法里可Neng有hen多代码是不需要同步的。这时候，同步代码块就派上用场了。我们Ke以指定任意一个对象作为锁，只锁住那几行关键的代码。

public void saleTicket {
    // 其他无关逻辑...
    // 只对操作共享资源的代码加锁
    synchronized  {
        if  {
            // 临界区代码
        }
    }
}

开发中，优先使用同步代码块是性Neng优化的一个小技巧，尽量减少锁持有的时间，让其他线程Nenggeng快地拿到锁。

三、 ReentrantLock：geng灵活的“手动挡”豪车

synchronized虽然好用，但有时候显得有点“笨重”。在JDK 1.5之后Doug Lea大神为我们带来了 java.util.concurrent.locks.Lock 接口，其中Zui著名的实现类就是 ReentrantLock。

Ru果说synchronized是自动挡汽车，那ReentrantLock就是手动挡赛车。它需要你手动调用 lock 加锁，并在 finally 块中手动调用 unlock 释放锁。虽然麻烦，但它提供了synchronized无法企及的高级功Neng：

可中断获取锁时Ke以被中断，解决死锁僵局。

公平锁选择Ke以设置为公平锁，先来后到；synchronized默认是非公平的，允许插队。

尝试非阻塞尝试获取锁，拿不到就立刻走人，不傻等。

kan下面这个例子，感受一下手动挡的魅力：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    private static int ticketNum = 100;
    // 创建一把全局唯一的锁
    private static final Lock lock = new ReentrantLock;
    public static void saleTicket {
        // 必须手动加锁
        lock.lock;
        try {
            // 这里的代码就是安全的
            if  {
                System.out.println.getName + "卖出第" + ticketNum + "张票，剩余：" + );
            }
        } finally {
            // 必须在finally中释放，防止异常导致锁死
            lock.unlock;
        }
    }
    public static void main {
        for  {
            new Thread.start;
        }
    }
}

特别提醒使用ReentrantLock时unlock 一定要写在 finally 里！这是铁律，否则一旦业务抛出异常，锁没释放，其他线程就会永远堵在门口，造成系统瘫痪。

四、 锁的“十八般武艺”：分类与特性

面试中，面试官特别喜欢问各种锁的区别。其实这些概念并不冲突，只是从不同维度对锁进行了分类。我们用大白话来梳理一下。

1. 悲观锁 vs 乐观锁

这是kan待并发冲突的两种态度。

悲观锁是个悲观主义者，总觉得别人会来抢数据。所以每次操作前dou先上锁，把别人挡在外面。synchronized和ReentrantLockdou是典型的悲观锁。

乐观锁是个乐观主义者，觉得大家相安无事。操作时不上锁，而是在geng新数据的一瞬间，判断一下数据有没有被改过。Ru果没改过就geng新；Ru果改过了就放弃或重试。Java中的 Atomic 原子类底层就是基于CAS实现的乐观锁。

2. 公平锁 vs 非公平锁

这是关于排队的问题。

公平锁讲究先来后到，线程严格按照申请锁的顺序排队。虽然公平，但维护队列需要成本，性Neng相对较低。

非公平锁允许插队。新来的线程可Neng直接抢到锁，不用排队。这样吞吐量geng高，但可Neng导致某些线程一直抢不到锁。synchronized和默认的ReentrantLockdou是非公平锁。

3. 可重入锁

这个概念hen重要。简单说就是同一个线程Ke以多次获取同一把锁，不会把自己锁死。比如在同步方法里调用了该对象的另一个同步方法，Ru果锁不可重入，那就死锁了。synchronized和ReentrantLockdou是可重入锁。

4. 共享锁 vs 排他锁

排他锁同一时间只Neng有一个线程持有，读写dou互斥。比如写文章，只Neng一个人写。

共享锁同一时间Ke以有多个线程同时持有，通常用于读。比如kan报纸，大家Ke以一起kan。经典的 ReadWriteLock 就是读写锁，读锁是共享的，写锁是排他的。

五、 线程间的“暗语”：等待与通知机制

多线程世界里光有锁是不够的，线程之间还需要配合，也就是“通信”。Zui经典的场景就是“生产者-消费者模型”：生产者Zuo完了数据，得通知消费者来拿；消费者拿完了得通知生产者继续Zuo。

Java中用于线程通信的方法是 Object 类提供的 waitnotify 和 notifyAll。注意，这些方法必须在同步代码块或同步方法中调用，因为必须拿到锁对象才Neng操作它。

wait让当前线程释放锁并进入等待状态，直到被唤醒。

notify随机唤醒一个在当前锁上等待的线程。

notifyAll唤醒所有在当前锁上等待的线程。

这里有个细节：wait 和 sleep douNeng让线程暂停，但 wait 会释放锁，而 sleep 不会。这可是面试高频考点！

下面我们用代码演示一下生产者和消费者是如何通过“暗语”配合的：

/**
 * 生产者消费者模型：线程间通信的教科书级案例
 */
public class ProducerConsumerDemo {
    // 共享资源：库存
    private static int stock = 0;
    // 锁对象
    private static final Object lock = new Object;
    // 生产者任务
    static class Producer implements Runnable {
        @Override
        public void run {
            while  {
                synchronized  {
                    // Ru果库存满了就等待消费者消费
                    while  {
                        try {
                            lock.wait;
                        } catch  {
                            e.printStackTrace;
                        }
                    }
                    // 生产商品
                    stock++;
                    System.out.println.getName + "生产了一件商品，当前库存：" + stock);
                    // 通知消费者赶紧来买
                    lock.notifyAll;
                }
            }
        }
    }
    // 消费者任务
    static class Consumer implements Runnable {
        @Override
        public void run {
            while  {
                synchronized  {
                    // Ru果没货了就等生产者生产
                    while  {
                        try {
                            lock.wait;
                        } catch  {
                            e.printStackTrace;
                        }
                    }
                    // 消费商品
                    stock--;
                    System.out.println.getName + "消费了一件商品，当前库存：" + stock);
                    // 通知生产者继续干
                    lock.notifyAll;
                }
            }
        }
    }
    public static void main {
        new Thread, "生产者1").start;
        new Thread, "消费者1").start;
        new Thread, "消费者2").start;
    }
}

在这个例子中，我们使用了 while 循环来判断条件，而不是 if。这是为了防止“虚假唤醒”，确保线程被唤醒后 检查条件，万无一失。

六、 ：如何选择合适的锁？

聊了这么多，Zui后落实到开发中，我们该怎么选？

其实原则hen简单：

常规场景Ru果不需要高级功Neng，优先使用 synchronized。它写起来简单，JVM优化得也极好，不容易出错。

复杂场景Ru果你需要公平锁、需要尝试获取锁、或者需要在中断时释放锁，那就果断选择 ReentrantLock。

读多写少Ru果读操作远远多于写操作，考虑使用 ReadWriteLock，利用共享锁提升并发性Neng。

多线程是一门艺术，也是一门玄学。理解了原理，掌握了锁机制，你才Neng在并发洪流中游刃有余。希望这篇文章Neng帮你彻底搞定Java多线程的核心难点，下次面试再遇到这些问题，不仅Neng答上来还Neng让面试官眼前一亮！

---