深入理解Java并发同步机制

本文深入探讨java中多线程同步的关键机制，通过分析实际场景，详细阐述`synchronized`关键字在方法和代码块层面的作用、内存可见性问题、`wait()`与`notify()`/`notifyall()`的协作原理，以及如何正确协调lambda表达式创建的线程。旨在帮助开发者构建健壮、高效的并发应用。

1. synchronized代码块与内存可见性

在Java多线程编程中，确保共享数据的一致性和可见性至关重要。synchronized关键字是实现这一目标的核心工具。它不仅保证了代码块的原子性，还通过内存屏障确保了内存可见性。

场景分析：考虑一个共享列表a和两个操作方法foo和goo：

List a = new ArrayList(); // 共享列表void foo(int i) {    synchronized (a) { // 对列表a进行同步        a.add(i);    }}int goo() {    return a.size(); // 未同步访问}

问题： 如果多个线程同时运行，一个线程在foo方法中执行同步代码块时，其他线程是否可以访问未同步的goo方法，从而读取a的尺寸？反之，如果一个线程通过未同步的goo访问a，另一个线程能否进入foo的同步块？

深入解析：是的，在上述代码中，线程可以同时执行foo的同步块和goo的非同步块。

foo执行时访问goo： 当一个线程在foo中持有a的锁并执行a.add(i)时，其他线程可以自由调用goo()。goo()方法没有对a进行同步，因此它不会尝试获取a的锁。这意味着goo()可能会读取到a的过时（stale）状态，即在foo中添加的元素可能尚未对goo()可见，或者在foo执行过程中，goo()读取到一个不一致的中间状态。这会引发内存可见性问题和数据不一致性。goo执行时进入foo： 当一个线程在执行goo()时，它没有持有任何锁。因此，另一个线程可以随时尝试进入foo()的同步块。由于foo()需要获取a的锁，它会尝试获取该锁。如果此时没有其他线程持有a的锁（例如，前一个foo调用已完成），它将成功进入；否则，它将等待直到锁可用。

正确做法：为了确保共享数据a的线程安全，所有访问a（无论是读还是写）的代码都必须在同一个锁对象上进行同步。这样可以保证操作的原子性和内存可见性。

import java.util.ArrayList;import java.util.List;public class SynchronizedListExample {    private final List sharedList = new ArrayList();    // 写入操作，同步在sharedList对象上    public void addElement(int i) {        synchronized (sharedList) {            sharedList.add(i);            System.out.println(Thread.currentThread().getName() + " added: " + i + ", size: " + sharedList.size());        }    }    // 读取操作，同样同步在sharedList对象上，确保可见性    public int getSize() {        synchronized (sharedList) {            int size = sharedList.size();            System.out.println(Thread.currentThread().getName() + " read size: " + size);            return size;        }    }    public static void main(String[] args) throws InterruptedException {        SynchronizedListExample example = new SynchronizedListExample();        // 启动多个线程进行读写        Runnable writer = () -> {            for (int i = 0; i  {            for (int i = 0; i < 5; i++) {                example.getSize();                try {                    Thread.sleep(70); // 模拟耗时操作                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            }        };        Thread t1 = new Thread(writer, "Writer-1");        Thread t2 = new Thread(reader, "Reader-1");        Thread t3 = new Thread(writer, "Writer-2");        t1.start();        t2.start();        t3.start();        t1.join();        t2.join();        t3.join();        System.out.println("Final list size: " + example.getSize());    }}

总结： 任何对共享可变状态的访问都必须通过同步机制进行保护，并且所有访问都必须在同一个锁对象上进行同步。否则，可能导致数据不一致和内存可见性问题。

2. wait(), notifyAll() 与锁的释放和获取

wait(), notify()和notifyAll()是Object类的方法，它们只能在synchronized方法或同步代码块内部调用，并且必须在当前线程持有的锁对象上调用。它们用于实现线程间的协作和通信。

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

场景分析：考虑以下同步方法：

void synchronized foo() { // 锁对象是'this'    // do stuff 1    notifyAll();    // do stuff 2    if (someStatement)        return;    try {        wait(); // 线程在此等待    } catch (InterruptedException e) {        Thread.currentThread().interrupt();    }    // do stuff 3}

问题： 如果一个线程A进入foo并执行到wait()，它会释放this对象的锁。此时，如果另一个线程B进入foo并执行到notifyAll()，线程A应该被唤醒并继续执行，但线程B此时正持有this的锁。那么，线程A会如何处理？

深入解析：

线程A执行wait()： 当线程A执行到wait()方法时，它会：释放当前线程持有的this对象的锁。 这是wait()的关键行为，允许其他线程进入foo方法或任何其他同步在this对象上的方法/块。进入等待状态。 线程A会进入this对象的等待队列，直到被唤醒。线程B进入并执行notifyAll()： 此时，this对象的锁已被线程A释放，所以线程B可以成功获取this的锁并进入foo方法。当线程B执行到notifyAll()时：notifyAll()会唤醒所有在this对象上等待的线程（包括线程A）。被唤醒的线程（如线程A）并不会立即继续执行。 它会从等待队列移动到就绪队列，重新尝试获取this对象的锁。锁的竞争： 此时，线程B仍然持有this对象的锁。因此，被唤醒的线程A将无法立即获取锁，它会再次进入阻塞状态，等待线程B释放锁。线程B释放锁： 当线程B执行完foo方法（或者在foo方法内部因为wait()而释放锁），它会释放this对象的锁。线程A获取锁并继续： 线程A在线程B释放锁后，会竞争获取this对象的锁。一旦成功获取锁，它将从wait()方法之后继续执行foo方法中的剩余代码（do stuff 3）。

重要提示：

wait()方法通常需要在一个循环中调用，以防止“虚假唤醒”（spurious wakeups）和确保等待条件真正满足。notifyAll()通常比notify()更安全，因为它会唤醒所有等待的线程，避免“丢失的唤醒”问题，尤其是在有多种等待条件时。

public class WaitNotifyExample {    private boolean conditionMet = false;    public synchronized void producer() {        System.out.println(Thread.currentThread().getName() + ": Producer started.");        // do stuff 1        conditionMet = true; // 改变条件        notifyAll(); // 唤醒所有等待的消费者线程        System.out.println(Thread.currentThread().getName() + ": Notified. (do stuff 2)");        // do stuff 2        // 假设这里还有一些工作，或直接返回        // if (someStatement) return; // 模拟提前返回        System.out.println(Thread.currentThread().getName() + ": Producer finished its work before wait.");        // 假设这里也可能需要等待某种条件        // try {        //     wait(); // 如果生产者也需要等待，它会释放锁        // } catch (InterruptedException e) {        //     Thread.currentThread().interrupt();        // }        // System.out.println(Thread.currentThread().getName() + ": Producer continued after its own wait.");    }    public synchronized void consumer() {        System.out.println(Thread.currentThread().getName() + ": Consumer started.");        // do stuff 1        while (!conditionMet) { // 循环等待，防止虚假唤醒            System.out.println(Thread.currentThread().getName() + ": Condition not met, waiting...");            try {                wait(); // 释放锁并等待            } catch (InterruptedException e) {                Thread.currentThread().interrupt();                return;            }        }        System.out.println(Thread.currentThread().getName() + ": Condition met, continuing. (do stuff 3)");        // do stuff 3    }    public static void main(String[] args) throws InterruptedException {        WaitNotifyExample example = new WaitNotifyExample();        Thread consumerThread1 = new Thread(example::consumer, "Consumer-1");        Thread consumerThread2 = new Thread(example::consumer, "Consumer-2");        Thread producerThread = new Thread(example::producer, "Producer-1");        consumerThread1.start();        consumerThread2.start();        Thread.sleep(100); // 确保消费者线程先进入等待状态        producerThread.start();        consumerThread1.join();        consumerThread2.join();        producerThread.join();    }}

3. 协调Lambda表达式创建的线程

当使用Lambda表达式创建线程时，其本质仍然是实现了Runnable接口的对象。要实现线程间的wait()/notify()通信，关键在于确定一个共享的监视器对象（monitor object），所有参与通信的线程都必须在该对象上进行同步。

HDHCMS (集网站建站与客户管理于一体的系统)

HDHCMS自2025年3月13日起取消授权功能，前台展示完全不受授权限制。 下载系统上线后要先运行后台URL才可正常运行。 URL首先要运行：http://主域名/admin/ HDHCMS是一款轻量级的专注于企业网站建设、企业办公管理与企业客户管理的内容管理系统，同步支持PC与手机网站的建设，后台支持微信公众号的接入。 开发脚本为ASP

12 查看详情

场景分析：

class A implements Runnable { // A实现了Runnable，但这不是重点    Thread b; // 引用一个Lambda创建的线程    void foo() {        b = new Thread(() -> {            // some lambda function logic            System.out.println(Thread.currentThread().getName() + " is running.");            // 假设这里需要等待通知            // 怎么等待通知？        }, "Lambda-Thread");        b.start();    }    void goo() {        // 如何通知线程b？    }    @Override    public void run() {        // A的run方法，可能不被使用，或有其他用途    }}

问题： 如何在goo()方法中通知由Lambda表达式创建的线程b？

深入解析：notify()和notifyAll()方法不是直接在Thread对象上调用的，而是作用于线程正在等待的监视器对象上。Thread b只是一个线程的引用，它本身不是一个合适的监视器对象来协调其内部的Lambda逻辑。

要实现线程间的通知，你需要：

创建一个共享的监视器对象。 这个对象可以是任何Java对象，但通常是一个专门用于同步的final对象。让需要等待的线程在监视器对象上调用wait()。让需要通知的线程在同一个监视器对象上调用notify()或notifyAll()。所有wait()和notify()/notifyAll()调用都必须在持有该监视器对象的锁的同步块中进行。

示例：使用共享对象进行通知

public class LambdaThreadCoordination {    // 共享的监视器对象，用于线程间的通信    private final Object monitor = new Object();    private boolean condition = false; // 共享条件    public void startLambdaThread() {        Thread b = new Thread(() -> {            String threadName = Thread.currentThread().getName();            System.out.println(threadName + ": Lambda thread started.");            synchronized (monitor) { // 必须同步在同一个监视器对象上                while (!condition) { // 循环等待条件                    System.out.println(threadName + ": Condition not met, waiting...");                    try {                        monitor.wait(); // 释放monitor的锁并等待                    } catch (InterruptedException e) {                        Thread.currentThread().interrupt();                        System.out.println(threadName + ": Interrupted while waiting.");                        return;                    }                }                System.out.println(threadName + ": Condition met, proceeding.");                // 执行Lambda线程的后续逻辑            }            System.out.println(threadName + ": Lambda thread finished its work.");        }, "Worker-Lambda-Thread");        b.start();    }    public void notifyLambdaThread() {        synchronized (monitor) { // 必须同步在同一个监视器对象上            System.out.println(Thread.currentThread().getName() + ": Notifying the lambda thread...");            condition = true; // 改变条件            monitor.notifyAll(); // 唤醒所有在monitor上等待的线程            System.out.println(Thread.currentThread().getName() + ": Notification sent.");        }    }    public static void main(String[] args) throws InterruptedException {        LambdaThreadCoordination coordinator = new LambdaThreadCoordination();        // 启动Lambda线程，它会立即进入等待状态        coordinator.startLambdaThread();        Thread.sleep(100); // 确保Lambda线程有时间启动并进入等待        // 在主线程中调用通知方法        coordinator.notifyLambdaThread();        // 可以在这里等待Lambda线程结束，如果需要        // Thread.sleep(500); // 简单的等待    }}

总结：无论线程是如何创建的（匿名内部类、Lambda表达式、实现Runnable接口的类），wait()和notify()/notifyAll()机制的核心都是基于一个共享的监视器对象。线程必须在持有该监视器对象的锁的情况下调用这些方法。Thread对象本身通常不作为通信的监视器对象，而是作为线程的执行实体。

总结与最佳实践

Java的同步机制是构建可靠并发应用的基础。理解synchronized关键字的原子性和可见性保证，以及wait()/notify()/notifyAll()的协作原理，是至关重要的。

关键点回顾：

一致的同步： 所有访问共享可变状态的操作都必须在同一个锁对象上进行同步，以确保数据一致性和内存可见性。wait()/notify()的锁行为： wait()会释放锁并进入等待，被唤醒后需要重新获取锁才能继续执行。notify()/notifyAll()必须在持有锁的情况下调用。循环中的wait()： 始终在while循环中调用wait()，以处理虚假唤醒并重新检查条件。共享监视器对象： 线程间通信（wait()/notify()）需要一个所有参与线程都能访问的共享监视器对象，而不是直接在Thread对象上操作。notifyAll()优先： 在不确定哪个线程需要被唤醒时，优先使用notifyAll()，以避免“丢失的唤醒”问题。

进阶提示：对于更复杂的并发场景，java.util.concurrent包提供了更高级和灵活的并发工具，如Lock接口（ReentrantLock）、Semaphore、CountDownLatch、CyclicBarrier以及各种BlockingQueue实现。这些工具提供了比synchronized和wait()/notify()更细粒度的控制和更丰富的功能，有助于编写更健壮、更易于维护的并发代码。

以上就是深入理解Java并发同步机制的详细内容，更多请关注创想鸟其它相关文章！