Java并发编程中的同步机制深度解析

import java.util.ArrayList;
import java.util.List;

public class SynchronizedExample {
    private List<Integer> a = new ArrayList<>();

    // 方法foo使用synchronized块来保护对列表a的写入操作
    public void foo(int i) {
        synchronized (a) { // 锁定列表a对象
            a.add(i);
            System.out.println(Thread.currentThread().getName() + " added: " + i + ", current size: " + a.size());
        }
    }

    // 方法goo读取列表a的大小
    public int goo() {
        // 错误的示例：未同步访问共享资源
        // return a.size(); 

        // 正确的同步方式：也需要锁定列表a对象
        synchronized (a) { 
            int size = a.size();
            System.out.println(Thread.currentThread().getName() + " read size: " + size);
            return size;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedExample example = new SynchronizedExample();

        // 线程1执行foo
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.foo(i);
                try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "WriterThread");

        // 线程2执行goo
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.goo();
                try { Thread.sleep(15); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        }, "ReaderThread");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println("Final size of list a: " + example.a.size());
    }
}

public class WaitNotifyExample {
    private boolean conditionMet = false;

    public synchronized void fooWithWaitNotify() {
        System.out.println(Thread.currentThread().getName() + " entered fooWithWaitNotify.");
        // do stuff before waiting
        System.out.println(Thread.currentThread().getName() + " doing stuff before wait.");

        // 假设某个条件满足后才需要通知
        if (!conditionMet) {
            try {
                System.out.println(Thread.currentThread().getName() + " is about to wait, releasing lock.");
                wait(); // 释放当前对象的锁，并进入等待状态
                System.out.println(Thread.currentThread().getName() + " woke up and re-acquired lock.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        // do stuff after waiting or if conditionMet was true initially
        System.out.println(Thread.currentThread().getName() + " doing stuff after wait/condition met.");

        // 模拟条件满足，通知其他等待线程
        if (Thread.currentThread().getName().equals("NotifierThread")) {
            conditionMet = true; // 改变条件
            System.out.println(Thread.currentThread().getName() + " notifying all waiting threads.");
            notifyAll(); // 通知所有等待在当前对象上的线程
        }
        System.out.println(Thread.currentThread().getName() + " exiting fooWithWaitNotify.");
    }

    public static void main(String[] args) throws InterruptedException {
        WaitNotifyExample example = new WaitNotifyExample();

        Thread t1 = new Thread(() -> {
            example.fooWithWaitNotify();
        }, "WaiterThread");

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(100); // 确保WaiterThread先进入等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            example.fooWithWaitNotify(); // 这个线程会触发notifyAll
        }, "NotifierThread");

        t1.start();
        t2.start();

        t1.join();
        t2.join();
    }
}

public class A implements Runnable {
    Thread b;
    // 声明一个共享的锁对象，可以是this，也可以是专门创建的Object
    private final Object lock = new Object(); 
    private boolean bStarted = false;

    public void foo() {
        b = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " (lambda thread) started.");
            synchronized (lock) { // Lambda线程在lock对象上等待
                bStarted = true;
                lock.notify(); // 通知foo方法b线程已经启动
                try {
                    System.out.println(Thread.currentThread().getName() + " (lambda thread) waiting for notification...");
                    lock.wait(); // 等待goo方法的通知
                    System.out.println(Thread.currentThread().getName() + " (lambda thread) received notification from goo!");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println(Thread.currentThread().getName() + " (lambda thread) finished.");
        }, "LambdaThread-B");

        synchronized (lock) {
            b.start();
            // 等待LambdaThread-B启动并通知
            while (!bStarted) {
                try {
                    lock.wait(); 
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Main thread: LambdaThread-B has started.");
        }
    }

    public void goo() {
        synchronized (lock) { // goo方法也在同一个lock对象上同步
            System.out.println(Thread.currentThread().getName() + " in goo, notifying LambdaThread-B.");
            lock.notify(); // 通知等待在lock对象上的线程
        }
    }

    @Override
    public void run() {
        // This run method is not directly used in the example but is required by Runnable
    }

    public static void main(String[] args) throws InterruptedException {
        A instance = new A();
        instance.foo(); // 启动lambda线程

        Thread.sleep(1000); // 确保lambda线程有时间进入等待状态

        instance.goo(); // 通知lambda线程
        instance.b.join(); // 等待lambda线程结束
        System.out.println("All threads finished.");
    }
}