深入理解Java并发同步机制-java教程-PHP中文网

深入理解Java并发同步机制

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

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

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

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

List<Integer> 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<Integer> 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 < 5; i++) {
                example.addElement(i);
                try {
                    Thread.sleep(50); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable reader = () -> {
            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），所有参与通信的线程都必须在该对象上进行同步。

钉钉 AI 助理

钉钉AI助理汇集了钉钉AI产品能力，帮助企业迈入智能新时代。

查看详情

场景分析：

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并发同步机制的详细内容，更多请关注php中文网其它相关文章！