本文深入探讨java并发编程中的同步机制，重点解析`synchronized`关键字在方法和代码块中的应用，以及`wait()`、`notify()`和`notifyall()`方法实现线程间通信的原理。文章通过具体场景分析了共享资源访问的线程安全性问题，强调了正确使用锁对象的重要性，并提供了示例代码，帮助读者理解如何避免数据不一致和实现有效的线程协作。
理解Java中的同步机制
在多线程环境中，为了保证共享数据的完整性和一致性，Java提供了多种同步机制。其中，synchronized关键字是最基本也是最常用的方式，它基于监视器（Monitor）锁实现。每个Java对象都可以作为一个监视器锁，当一个线程进入synchronized代码块或方法时，它会尝试获取该对象的锁。如果锁已被其他线程持有，当前线程就会被阻塞，直到锁被释放。
1. synchronized与共享资源访问
synchronized关键字可以用于修饰方法或代码块。当修饰方法时，它锁定的是当前实例对象（对于静态方法，锁定的是类的Class对象）；当修饰代码块时，它锁定的是括号中指定的对象。
考虑以下场景，一个共享列表a和两个操作它的方法：
import java.util.ArrayList;import java.util.List;public class SynchronizedExample { private List 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 { 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()); }}
分析：
立即学习“Java免费学习笔记（深入）”；
Ai Mailer
使用Ai Mailer轻松制作电子邮件
49 查看详情 未同步的goo()方法： 如果goo()方法不使用synchronized (a)，那么当一个线程在foo()中持有a的锁并修改a时，另一个线程可以同时进入goo()并访问a。这会导致严重的数据不一致问题。例如，foo()可能已经添加了一个元素，但由于内存可见性问题，goo()可能仍然读取到旧的、未更新的列表大小。synchronized不仅保证了原子性，还保证了内存可见性。正确的同步： 为了确保数据一致性，所有对共享资源（例如这里的List a）的访问（无论是读还是写）都必须通过相同的锁对象进行同步。这意味着goo()方法也应该使用synchronized (a)来保护对a.size()的访问。当一个线程在foo()中获取a的锁时，其他尝试进入foo()或goo()（如果goo()也同步在a上）的线程将被阻塞，直到锁被释放。
结论： 只要访问的是同一个共享对象，并且使用了相同的锁对象进行同步，那么在任何时刻，只有一个线程能够执行受该锁保护的代码块。如果对共享资源的访问没有全部同步，则无法保证线程安全。
2. wait(), notify(), notifyAll() 实现线程协作
wait(), notify(), notifyAll()是Object类的方法，用于实现线程间的协作和通信。它们必须在synchronized代码块或方法内部调用，并且操作的锁对象必须是当前线程所持有的监视器锁。
考虑一个使用wait()和notifyAll()的同步方法：
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(); }}
分析：
立即学习“Java免费学习笔记（深入）”；
线程1 (WaiterThread)进入fooWithWaitNotify()： 它获取了example对象的锁。WaiterThread调用wait()： 当WaiterThread执行到wait()时，它会立即释放example对象的锁，然后进入等待状态（WAITING或TIMED_WAITING）。线程2 (NotifierThread)进入fooWithWaitNotify()： 此时example对象的锁已被WaiterThread释放，所以NotifierThread可以成功获取锁并进入方法。NotifierThread调用notifyAll()： NotifierThread执行到notifyAll()，它会唤醒所有（包括WaiterThread）正在example对象上等待的线程。但是，被唤醒的线程（WaiterThread）不会立即恢复执行。它必须重新尝试获取example对象的锁。NotifierThread退出方法： NotifierThread继续执行，直到方法结束，此时它会释放example对象的锁。WaiterThread恢复执行： NotifierThread释放锁后，WaiterThread才能成功重新获取锁，然后从wait()调用的下一行代码继续执行。
关键点： wait()会释放锁，而notify()/notifyAll()不会释放锁，它们只是将等待线程从等待队列移到同步队列，等待获取锁。
3. 线程间通信与notify()特定线程
wait()和notify()/notifyAll()是基于对象监视器的机制，而不是直接操作Thread实例。这意味着你不能直接“通知”一个特定的Thread对象。相反，你需要让需要被通知的线程在一个共享的锁对象上调用wait()，而通知者则在该同一个共享锁对象上调用notify()或notifyAll()。
如果你的目标是通知一个由Lambda表达式创建的线程，你需要确保这个Lambda表达式所运行的线程能够访问到一个共享的锁对象，并且这个锁对象也能够被通知者访问。
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."); }}
分析：
立即学习“Java免费学习笔记（深入）”；
共享锁对象： 在A类中定义了一个private final Object lock = new Object();作为共享的锁对象。Lambda线程的wait()： b线程（Lambda表达式）在其内部通过synchronized (lock)获取lock对象的锁，然后调用lock.wait()进入等待状态。goo()方法的notify()： goo()方法也通过synchronized (lock)获取lock对象的锁，然后调用lock.notify()来唤醒等待在lock对象上的线程（即b线程）。foo()中的初始同步： foo()方法也使用lock对象进行同步，并等待b线程启动后发出的通知，这确保了b线程已经准备好接收goo()的通知。
通过这种方式，即使你没有直接的Thread引用来操作，只要能够访问到同一个共享的锁对象，就可以实现线程间的通信。
总结与最佳实践
Java的同步机制是构建健壮并发应用程序的基础。正确理解和应用synchronized、wait()、notify()和notifyAll()至关重要。
同步所有对共享可变状态的访问： 任何时候，只要有多个线程可能同时读写一个共享的可变数据，就必须使用同步机制来保护它，并且所有访问点都必须使用相同的锁。选择合适的锁对象： 对于实例方法，通常使用this；对于静态方法，使用Class对象。对于代码块，可以选择任何非null的Object实例作为锁。避免使用字符串字面量或基本类型的包装类作为锁，因为它们可能被JVM缓存，导致意想不到的共享。wait()/notify()必须在synchronized块中调用： 并且要确保它们操作的是当前线程持有的锁对象。始终在循环中检查等待条件： 使用while (condition)而不是if (condition)来检查wait()后的条件，因为线程可能被虚假唤醒（spurious wakeup），或者被其他线程通知但条件尚未真正满足。考虑使用java.util.concurrent包： 对于更复杂的并发场景，java.util.concurrent包提供了更高级、更灵活、性能更好的并发工具，如ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier以及各种并发集合（如ConcurrentHashMap、BlockingQueue）。它们通常比内置的synchronized提供更好的控制和可伸缩性。避免死锁： 仔细设计锁的获取顺序，避免循环依赖，以防止死锁的发生。
通过深入理解这些机制并遵循最佳实践，开发者可以有效地构建安全、高效的并发Java应用程序。
以上就是Java并发编程中的同步机制深度解析的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1031522.html
微信扫一扫 
支付宝扫一扫 
