好的，各位观众老爷，各位技术大咖，欢迎来到老码农的线程同步小课堂！今天咱们要聊聊 Java 多线程的那些事儿，特别是那让人又爱又恨的同步机制。
开场白：多线程，甜蜜的诱惑与苦涩的陷阱
多线程编程，就像一位风姿绰约的舞者，优雅而高效。它能让我们的程序在多个任务之间翩翩起舞，充分利用 CPU 的每一丝性能。想象一下，一边下载电影，一边浏览网页，互不干扰，多么的美好！
然而，这位舞者也暗藏玄机。如果稍有不慎，就会掉入数据竞争和死锁的陷阱，导致程序崩溃，数据混乱，甚至让你的电脑死机！ 😱
所以，要想驾驭这位舞者，必须掌握她的舞步——线程同步机制。今天，我们就来深入剖析 synchronized 关键字、Lock 接口以及并发工具类这三大法宝，助你成为多线程编程的大师！
第一幕：synchronized 关键字：简单粗暴却有效的守护者
synchronized 关键字，就像一位忠诚的门卫，守护着共享资源的入口。它能确保在同一时刻，只有一个线程能够访问被保护的代码块或方法。
1. 语法与用法：
synchronized 关键字有两种主要用法：
-
同步代码块：
synchronized (object) { // 需要同步的代码 }这里的
object可以是任何对象，它充当了“锁”的角色。当一个线程进入同步代码块时，它会尝试获取object的锁。如果锁已经被其他线程持有，那么该线程就会被阻塞，直到锁被释放。 -
同步方法：
public synchronized void myMethod() { // 需要同步的代码 }对于普通方法，
synchronized相当于synchronized (this)，即以当前对象作为锁。对于静态方法，synchronized相当于synchronized (MyClass.class)，即以类对象作为锁。
2. 工作原理：
synchronized 的底层实现依赖于操作系统的互斥锁 (Mutex)。当一个线程获取锁时，操作系统会将其标记为“持有锁”，其他线程尝试获取锁时会被阻塞。当线程释放锁时，操作系统会唤醒等待的线程，让它们竞争获取锁。
3. 优点与缺点：
- 优点： 简单易用，易于理解。
- 缺点： 性能相对较低，功能有限。无法中断等待锁的线程，也无法设置超时时间。
4. 案例分析：
假设我们有一个共享的计数器：
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}如果没有 synchronized 关键字，多个线程同时调用 increment() 方法可能会导致数据竞争，最终的 count 值可能小于预期。而有了 synchronized，就能保证每次只有一个线程能够访问 count 变量，从而避免数据竞争。
表格：synchronized 关键字总结
| 特性 | 描述 |
|---|---|
| 锁类型 | 隐式锁 (intrinsic lock) |
| 使用方式 | 同步代码块：synchronized (object) { ... }；同步方法：public synchronized void myMethod() { ... } |
| 优点 | 简单易用，适合简单的同步场景 |
| 缺点 | 性能相对较低，功能有限，无法中断等待锁的线程，无法设置超时时间 |
| 适用场景 | 简单的计数器、状态更新等场景，对性能要求不高 |
| 注意事项 | 避免过度使用 synchronized，可能导致性能瓶颈。尽量缩小同步代码块的范围。 |
| 底层原理 | 依赖操作系统的互斥锁 (Mutex) |
第二幕：Lock 接口：灵活强大的锁匠
Lock 接口，就像一位技艺精湛的锁匠，提供了更加灵活和强大的锁机制。它允许我们显式地获取和释放锁，并提供了更多高级功能。
1. 常用实现类：
- ReentrantLock： 可重入锁，允许同一个线程多次获取同一个锁。
- ReentrantReadWriteLock： 读写锁，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。
- StampedLock： 更高级的读写锁，提供了乐观读模式，可以进一步提高性能。
2. 语法与用法：
Lock lock = new ReentrantLock();
lock.lock(); // 获取锁
try {
// 需要同步的代码
} finally {
lock.unlock(); // 释放锁
}注意： 必须在 finally 块中释放锁，以确保锁在任何情况下都能被释放，防止死锁。
3. 优点与缺点：
- 优点： 更加灵活，可以中断等待锁的线程，可以设置超时时间，可以实现公平锁。
- 缺点： 使用起来稍微复杂一些，需要手动获取和释放锁。
4. 案例分析：
假设我们需要实现一个线程安全的队列：
class MyQueue<T> {
private final Lock lock = new ReentrantLock();
private final Condition notEmpty = lock.newCondition();
private final Queue<T> queue = new LinkedList<>();
public void put(T element) throws InterruptedException {
lock.lock();
try {
queue.offer(element);
notEmpty.signal(); // 通知等待的线程
} finally {
lock.unlock();
}
}
public T take() throws InterruptedException {
lock.lock();
try {
while (queue.isEmpty()) {
notEmpty.await(); // 等待队列不为空
}
return queue.poll();
} finally {
lock.unlock();
}
}
}在这个例子中，我们使用了 ReentrantLock 和 Condition 来实现线程安全的队列。Condition 允许线程在特定条件下等待和唤醒，从而实现了更加精细的线程同步。
表格：Lock 接口总结
| 特性 | 描述 |
|---|---|
| 锁类型 | 显式锁 (explicit lock) |
| 使用方式 | Lock lock = new ReentrantLock(); lock.lock(); try { ... } finally { lock.unlock(); } |
| 优点 | 更加灵活，可以中断等待锁的线程，可以设置超时时间，可以实现公平锁，可以使用 Condition 实现更加精细的线程同步 |
| 缺点 | 使用起来稍微复杂一些，需要手动获取和释放锁，容易忘记释放锁导致死锁 |
| 适用场景 | 需要更加灵活的锁机制，需要中断等待锁的线程，需要设置超时时间，需要实现公平锁，需要使用 Condition 实现更加精细的线程同步 |
| 注意事项 | 必须在 finally 块中释放锁，以确保锁在任何情况下都能被释放，防止死锁。 |
| 实现类 | ReentrantLock, ReentrantReadWriteLock, StampedLock 等 |
第三幕：并发工具类：站在巨人的肩膀上
Java 并发包 (java.util.concurrent) 提供了大量的并发工具类，就像一个工具箱，里面装满了各种各样的工具，可以帮助我们更加轻松地解决多线程问题。
1. 常用工具类：
- 原子类 (AtomicInteger, AtomicLong, AtomicReference)： 提供了原子操作，可以保证变量的线程安全性，而无需使用
synchronized或Lock。 - 并发集合 (ConcurrentHashMap, ConcurrentLinkedQueue, CopyOnWriteArrayList)： 提供了线程安全的集合类，可以在多线程环境下安全地访问和修改数据。
- 线程池 (ExecutorService, ThreadPoolExecutor)： 管理线程的生命周期，可以提高线程的利用率和程序的性能。
- CountDownLatch： 允许一个或多个线程等待其他线程完成操作。
- CyclicBarrier： 允许一组线程互相等待，直到所有线程都到达某个屏障点。
- Semaphore： 控制对共享资源的访问数量。
2. 案例分析：
假设我们需要统计网站的访问量：
class Website {
private AtomicInteger visits = new AtomicInteger(0);
public void visit() {
visits.incrementAndGet(); // 原子操作，保证线程安全
}
public int getVisits() {
return visits.get();
}
}在这个例子中，我们使用了 AtomicInteger 来保证 visits 变量的线程安全性，而无需使用 synchronized 或 Lock。
表格：并发工具类总结
| 工具类 | 描述 |
|---|---|
| 原子类 | 提供了原子操作，可以保证变量的线程安全性，而无需使用 synchronized 或 Lock。例如：AtomicInteger, AtomicLong, AtomicReference 等。 |
| 并发集合 | 提供了线程安全的集合类，可以在多线程环境下安全地访问和修改数据。例如：ConcurrentHashMap, ConcurrentLinkedQueue, CopyOnWriteArrayList 等。 |
| 线程池 | 管理线程的生命周期，可以提高线程的利用率和程序的性能。例如：ExecutorService, ThreadPoolExecutor 等。 |
| CountDownLatch | 允许一个或多个线程等待其他线程完成操作。例如，可以用于等待多个子任务完成。 |
| CyclicBarrier | 允许一组线程互相等待，直到所有线程都到达某个屏障点。例如，可以用于模拟赛跑，所有运动员都准备好后才能开始比赛。 |
| Semaphore | 控制对共享资源的访问数量。例如，可以用于限制同时访问数据库的连接数。 |
| BlockingQueue | 阻塞队列，提供了线程安全的队列操作，可以在多线程环境下安全地进行入队和出队操作。例如：ArrayBlockingQueue, LinkedBlockingQueue 等。 |
第四幕：死锁：多线程编程的终极 Boss
死锁，就像两位骑士互相抓着对方的头发，谁也不肯松手，最终两人都动弹不得。在多线程编程中，死锁是指两个或多个线程互相等待对方释放资源，导致所有线程都无法继续执行的状态。
1. 死锁产生的条件：
- 互斥条件： 资源必须处于独占状态，即一次只能被一个线程占用。
- 请求与保持条件： 线程已经持有至少一个资源，但又请求新的资源，而该资源已被其他线程占用。
- 不可剥夺条件： 线程已经获得的资源不能被强制剥夺，只能由线程自己释放。
- 循环等待条件： 存在一个线程等待资源的环路，即每个线程都在等待下一个线程所持有的资源。
2. 如何避免死锁：
- 避免嵌套锁： 尽量避免在一个同步代码块中获取另一个锁。
- 按照固定的顺序获取锁： 如果需要获取多个锁，确保所有线程都按照相同的顺序获取锁。
- 使用超时机制： 在获取锁时设置超时时间，如果超过超时时间仍未获取到锁，则放弃获取，释放已持有的资源。
- 使用死锁检测工具： Java 提供了死锁检测工具，可以帮助我们发现死锁问题。
3. 案例分析：
class DeadlockExample {
private static final Object lock1 = new Object();
private static final Object lock2 = new Object();
public static void method1() {
synchronized (lock1) {
System.out.println("Thread 1: Holding lock 1...");
try { Thread.sleep(10); } catch (InterruptedException e) {}
System.out.println("Thread 1: Waiting for lock 2...");
synchronized (lock2) {
System.out.println("Thread 1: Holding lock 1 & 2...");
}
}
}
public static void method2() {
synchronized (lock2) {
System.out.println("Thread 2: Holding lock 2...");
try { Thread.sleep(10); } catch (InterruptedException e) {}
System.out.println("Thread 2: Waiting for lock 1...");
synchronized (lock1) {
System.out.println("Thread 2: Holding lock 1 & 2...");
}
}
}
public static void main(String[] args) {
new Thread(() -> method1()).start();
new Thread(() -> method2()).start();
}
}在这个例子中，线程 1 先获取 lock1，然后尝试获取 lock2；线程 2 先获取 lock2，然后尝试获取 lock1。如果两个线程同时运行，就可能发生死锁。
第五幕：总结与展望
今天，我们一起学习了 Java 线程同步机制的三大法宝：synchronized 关键字、Lock 接口以及并发工具类。我们了解了它们的语法、用法、优缺点，以及如何避免死锁。
多线程编程是一门艺术，也是一门科学。只有不断学习和实践，才能真正掌握它，写出高效、稳定、可靠的多线程程序。
未来，随着 CPU 核心数的不断增加，多线程编程将变得越来越重要。我们需要不断探索新的并发模型和技术，例如反应式编程、协程等，以应对日益复杂的并发挑战。
希望今天的课程能对你有所帮助。感谢大家的收看！我们下期再见！ 👋