Java并发：synchronized机制与wait/notify的深度解析-java教程-PHP中文网

Java并发：synchronized机制与wait/notify的深度解析

DDD

发布： 2025-11-23 14:07:40

原创

792人浏览过

java并发：synchronized机制与wait/notify的深度解析

本文深入探讨Java并发编程中synchronized方法与synchronized块的使用，特别是涉及共享资源访问和wait()/notify()机制时的最佳实践。文章将分析使用不同锁对象可能导致的并发问题，强调确保内存同步和正确唤醒等待线程的关键原则，并提供避免常见陷阱的指导。

1. synchronized 方法与 synchronized 块基础

在Java中，synchronized关键字是实现线程同步的基本机制，它确保同一时刻只有一个线程可以执行被同步的代码块或方法。理解其工作原理对于编写正确的并发程序至关重要。

1.1 synchronized 方法

当一个方法被声明为 synchronized 时，它会锁定当前实例对象（this）。如果是静态 synchronized 方法，则会锁定该方法所属的 Class 对象。这意味着在任何给定时间，只有一个线程可以执行该对象的任何 synchronized 方法。

示例：

立即学习“Java免费学习笔记（深入）”；

class CircularBuffer {
    private byte[] buffer;
    private int size;
    private int head = 0;
    private int tail = 0;
    private int availableObjects = 0;

    public CircularBuffer(int capacity) {
        this.size = capacity;
        this.buffer = new byte[capacity];
    }

    synchronized void add(byte b) throws InterruptedException {
        if (availableObjects == size) { // 这里的 if 存在风险，应为 while
            wait(); // wait() 和 notifyAll() 默认作用于当前对象 (this)
        }
        buffer[tail] = b;
        tail = (tail + 1) % size;
        availableObjects++;
        notifyAll();
    }

    synchronized byte remove() throws InterruptedException {
        if (availableObjects == 0) { // 这里的 if 存在风险，应为 while
            wait();
        }
        byte element = buffer[head];
        head = (head + 1) % size;
        availableObjects--;
        notifyAll();
        return element;
    }
}

登录后复制

在上述实现中，add 和 remove 方法都锁定了 CircularBuffer 实例本身。这意味着在任何给定时间，只有一个线程可以执行 add 或 remove 方法，从而保证了对 buffer、head、tail 和 availableObjects 等共享状态的原子性访问。

1.2 synchronized 块

synchronized (object) 语法允许我们指定一个任意对象作为锁。这提供了更细粒度的控制，可以只同步代码的特定部分，或者使用不同的锁对象来同步不同的资源。

示例（存在问题的设计）：

What-the-Diff

检查请求差异，自动生成更改描述

103

查看详情

class CircularBufferProblematic {
    private final Object addLock = new Object();
    private final Object removeLock = new Object();
    private byte[] buffer;
    private int size;
    private int head = 0;
    private int tail = 0;
    private int availableObjects = 0; // 假设这里是 AtomicInteger 或普通 int

    public CircularBufferProblematic(int capacity) {
        this.size = capacity;
        this.buffer = new byte[capacity];
    }

    void add(byte b) throws InterruptedException {
        synchronized (addLock) { // 锁定 addLock
            while (availableObjects == size) { // 使用 while 循环是正确的改进
                addLock.wait();
            }
            buffer[tail] = b;
            tail = (tail + 1) % size;
            availableObjects++;
        }
        // 为什么这里需要第二个 synchronized 块？
        synchronized (removeLock) { // 锁定 removeLock
            removeLock.notifyAll();
        }
    }

    byte remove() throws InterruptedException {
        byte element;
        synchronized (removeLock) { // 锁定 removeLock
            while (availableObjects == 0) { // 使用 while 循环是正确的改进
                removeLock.wait();
            }
            element = buffer[head];
            head = (head + 1) % size;
            availableObjects--;
        }
        // 为什么这里需要第二个 synchronized 块？
        synchronized (addLock) { // 锁定 addLock
            addLock.notifyAll();
        }
        return element;
    }
}

登录后复制

2. wait()/notify() 机制与锁对象

Object 类的 wait()、notify() 和 notifyAll() 方法是Java中实现线程间协作的关键。它们允许线程在特定条件不满足时释放锁并进入等待状态，并在条件满足时被其他线程唤醒。

核心原则： 调用 wait()、notify() 或 notifyAll() 方法时，当前线程必须持有该方法所属对象的监视器（即锁）。如果不在相应的 synchronized 块中调用，会抛出 IllegalMonitorStateException。

这就是 CircularBufferProblematic 示例中额外 synchronized 块的根本原因：

在 add 方法中，removeLock.notifyAll() 必须在 synchronized (removeLock) 块中执行，因为它需要持有 removeLock 的监视器。
在 remove 方法中，addLock.notifyAll() 必须在 synchronized (addLock) 块中执行，因为它需要持有 addLock 的监视器。

这种设计是为了确保 wait() 和 notify() 调用的原子性，并防止在没有正确持有锁的情况下操作等待队列。

3. 使用不同锁对象引发的并发问题

尽管使用不同的锁对象可以实现更细粒度的控制，但当这些锁对象保护的是相同的共享状态时，就会引入严重的并发问题。CircularBufferProblematic 示例就存在这样的缺陷：

add 方法在 synchronized (addLock) 块中修改 buffer、tail 和 availableObjects。
remove 方法在 synchronized (removeLock) 块中读取 buffer、head 和 availableObjects。

问题分析： 由于 addLock 和 removeLock 是两个独立的锁，一个线程可以持有 addLock 并修改 buffer，而另一个线程同时持有 removeLock 并读取 buffer。这可能导致：

数据不一致： 读者可能读取到部分更新或过时的数据。例如，add 线程更新了 buffer 中的一个元素并递增了 availableObjects，但 remove 线程在看到 availableObjects 变化之前就读取了 buffer，从而读取到 null 或旧值。
内存可见性问题： synchronized 关键字除了提供互斥访问外，还保证了内存可见性。当一个线程释放锁时，它所做的所有写入操作都会被刷新到主内存；当一个线程获取锁时，它会从主内存中读取最新值。如果 add 和 remove 使用不同的锁，它们之间的内存同步就无法保证，一个线程对共享变量的修改可能对另一个线程不可见。

解决方案： 当多个操作（如生产者和消费者）需要访问和修改同一组共享状态变量时，它们必须使用同一个锁对象来保护这些共享状态。这样可以确保任何时候只有一个线程能够修改或读取这些变量，从而保证数据的一致性和内存可见性。

改进示例（使用单一锁）：

class CircularBufferCorrected {
    private final Object lock = new Object(); // 单一锁对象
    private byte[] buffer;
    private int size;
    private int head = 0;
    private int tail = 0;
    private int availableObjects = 0; // 可以是普通 int，因为有锁保护

    public CircularBufferCorrected(int capacity) {
        this.size = capacity;
        this.buffer = new byte[capacity];
    }

    public void add(byte b) throws InterruptedException {
        synchronized (lock) { // 锁定同一个对象
            while (availableObjects == size) { // 使用 while 循环
                lock.wait();
            }
            buffer[tail] = b;
            tail = (tail + 1) % size;
            availableObjects++;
            lock.notifyAll(); // 唤醒所有等待的线程
        }
    }

    public byte remove() throws InterruptedException {
        byte element;
        synchronized (lock) { // 锁定同一个对象
            while (availableObjects == 0) { // 使用 while 循环
                lock.wait();
            }
            element = buffer[head];
            head = (head + 1) % size;
            availableObjects--;
            lock.notifyAll(); // 唤醒所有等待的线程
            return element;
        }
    }
}

登录后复制

在这个改进版本中，add 和 remove 方法都同步在同一个 lock 对象上。这确保了对 buffer、head、tail 和 availableObjects 的所有访问都是互斥的，并且保证了内存可见性。availableObjects 也不再需要是 AtomicInteger，因为其操作在 synchronized 块内已受保护。