Java大师成长计划之第17天：锁与原子操作

📢 友情提示：

本文由银河易创AI（https://ai.eaigx.com）平台gpt-4o-mini模型辅助创作完成，旨在提供灵感参考与技术分享，文中关键数据、代码与结论建议通过官方渠道验证。

在多线程编程中，如何保证线程安全是开发者必须面对的重要课题。为了保证共享资源的正确访问，Java提供了多种锁机制和原子操作工具。在本篇博客中，我们将详细探讨sychronized关键字、java.util.concurrent包中的并发工具类，以及如何使用这些工具来确保线程安全。

一. synchronized关键字

1.1 什么是synchronized？

synchronized是Java中一种用于线程同步的关键字，它保证了在同一时刻只有一个线程可以执行被synchronized修饰的代码块或方法，从而确保对共享资源的线程安全访问。synchronized关键字使得线程可以排队执行同步区域中的代码，防止多个线程在同一时间访问共享资源时发生数据冲突或不一致的问题。

synchronized是实现线程安全最简单、最基础的工具之一。在多线程环境下，synchronized通过加锁的方式确保对共享资源的互斥访问，它可以被应用于方法或代码块。

1.2 synchronized的使用方式

Java中的synchronized关键字可以修饰方法或代码块。两种使用方式的区别在于锁的范围不同：当修饰方法时，整个方法都被加锁；当修饰代码块时，只有代码块内的部分被加锁。

1.2.1 同步方法

通过在方法声明中添加synchronized关键字，表示该方法是同步的。当线程调用该方法时，它必须首先获取该对象的锁，其他线程将被阻塞，直到当前线程执行完毕并释放锁。

public class Counter {private int count = 0;// 同步方法public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}

在这个例子中，increment()和getCount()方法都是同步的。当多个线程同时调用这两个方法时，synchronized保证了在同一时刻只有一个线程能够进入这两个方法，这样可以避免多个线程同时修改count导致的竞态条件。

1.2.1.1 锁的对象

当synchronized修饰实例方法时，它锁定的是当前对象的监视器（monitor）。这意味着对于同一个对象的多个线程调用，只有一个线程能够访问该同步方法，其他线程会被阻塞直到锁被释放。

public synchronized void increment() {count++;
}

在上面的例子中，increment()方法被修饰为同步方法，锁的是当前对象的监视器。每当一个线程执行该方法时，它会获取当前对象的锁，从而保证只有一个线程能够执行该方法。

1.2.1.2 静态方法中的synchronized

当synchronized修饰静态方法时，它锁定的是Class对象的监视器，而不是当前实例对象的监视器。也就是说，同一个类的所有线程访问静态方法时，都会争夺类对象的锁。

public static synchronized void incrementStatic() {count++;
}

在这种情况下，无论创建多少个类的实例，所有线程调用incrementStatic()方法时，都只能同时有一个线程在执行，因为它们争夺的是类锁。

1.2.2 同步代码块

synchronized还可以应用于代码块内，用来限制加锁的范围。与同步方法不同，同步代码块可以让开发者更精细地控制锁的粒度，只对需要同步的部分进行加锁，其他部分可以并行执行，从而提高程序的性能。

public class Counter {private int count = 0;public void increment() {synchronized (this) { // 锁定当前对象count++;}}public int getCount() {return count;}
}

在上面的代码中，synchronized (this)表示在increment()方法内部，只对count++操作进行加锁。这样，其他非同步代码部分可以并发执行，不会受到锁的影响，从而提高效率。

1.2.2.1 锁定任意对象

sychronized关键字中的对象锁定，不必局限于this，可以锁定任何对象。例如，使用类对象作为锁：

public class Counter {private int count = 0;private static final Object lock = new Object(); // 锁对象public void increment() {synchronized (lock) { // 锁定指定对象count++;}}public int getCount() {return count;}
}

在此例中，increment()方法内的synchronized块锁定了一个名为lock的静态对象。通过控制锁的对象，开发者可以实现更细粒度的同步控制，以避免不必要的资源竞争。

1.3 synchronized的原理

1.3.1 内部机制

Java中的synchronized通过锁机制来确保线程安全。具体而言，每个对象都有一个监视器锁（monitor），当线程执行synchronized代码块时，线程会首先尝试获取对象的锁。如果当前线程成功获得锁，其他线程将被阻塞，直到当前线程执行完毕并释放锁。释放锁时，其他被阻塞的线程将有机会争夺锁。

• 锁的获取：当线程执行被synchronized修饰的代码时，它首先要获取对象的监视器（锁）。如果其他线程已经持有该锁，当前线程就会进入阻塞状态，直到锁被释放。
• 锁的释放：当线程执行完同步方法或代码块后，自动释放锁，其他线程可以获取锁并继续执行。

1.3.2 锁的竞争与阻塞

当多个线程同时访问同一个同步方法或同步代码块时，它们会争夺锁。此时，其他线程无法继续执行被同步的代码，必须等待锁的释放。这种机制是实现线程同步的基础，但是也带来了性能上的开销，因为线程在等待锁时需要消耗CPU资源。

例如，如果有多个线程同时请求执行synchronized修饰的方法，只有一个线程能够成功获得锁并执行该方法，其他线程将被阻塞，直到获得锁为止。这会导致线程的上下文切换和阻塞等待，从而影响程序的执行效率。

1.3.3 死锁

死锁是多线程编程中的一个经典问题，通常发生在多个线程相互等待对方释放资源时。具体来说，死锁是指两个或更多线程在执行过程中因争夺资源而造成的相互等待，导致程序无法继续执行。

public class DeadlockExample {private final Object lock1 = new Object();private final Object lock2 = new Object();public void method1() {synchronized (lock1) {synchronized (lock2) {System.out.println("Method 1 executed");}}}public void method2() {synchronized (lock2) {synchronized (lock1) {System.out.println("Method 2 executed");}}}
}

在这个例子中，method1()和method2()两个方法分别锁住lock1和lock2。如果线程A先执行method1()并获得lock1，然后执行method2()并等待lock2，同时线程B执行method2()并获得lock2，然后尝试获取lock1，就会发生死锁。此时，两个线程相互等待对方释放锁，导致程序无法继续执行。

1.3.4 死锁的预防

为了避免死锁的发生，可以遵循以下几个策略：

• 避免锁嵌套：尽量避免在一个同步方法中再次获取其他锁。
• 锁的顺序：保证所有线程获取锁的顺序一致，从而避免互相等待。
• 使用tryLock()：ReentrantLock提供的tryLock()方法可以在指定时间内尝试获取锁，如果无法获取锁，当前线程可以选择其他操作，从而避免长时间等待。

1.4 synchronized的性能影响

synchronized关键字虽然能够保证线程安全，但也带来了一定的性能开销。主要的原因是锁的获取和释放操作是相对耗时的，尤其在高并发环境下，线程在等待锁时会产生上下文切换，从而增加系统负担。

1.4.1 锁竞争

当多个线程竞争同一锁时，线程的阻塞和唤醒会导致较高的上下文切换开销。如果竞争非常激烈，锁的持有时间较长，可能会导致系统性能下降。

1.4.2 锁的粒度

锁的粒度越大，性能开销就越大。为避免不必要的性能损失，可以尽量缩小同步的代码块范围，只对关键操作进行同步，而不是同步整个方法。

1.5 小结

synchronized是Java中最常用的线程同步机制，它通过锁的方式确保了在多线程环境中共享资源的安全访问。虽然synchronized非常简洁且容易使用，但它也有一定的性能开销，因此在高并发的场景下，开发者需要谨慎使用，并考虑使用更高效的同步机制（如ReentrantLock、ReadWriteLock等）。此外，死锁是使用synchronized时必须特别注意的问题，避免死锁的发生可以提高程序的可靠性和性能。

掌握sychronized关键字的正确使用，对于开发高效的并发程序是至关重要的。

二. java.util.concurrent包中的工具

Java提供了java.util.concurrent包中的许多工具类，以帮助开发者更加高效地实现线程安全、并发控制和任务调度。相较于传统的synchronized关键字，java.util.concurrent包中的工具类提供了更细粒度的控制，更高效的并发性，并且具备更灵活的配置选项。本文将重点介绍其中一些重要的并发工具，包括Executor框架、ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier、BlockingQueue等工具类。

2.1 Executor框架

Executor框架是java.util.concurrent包中最重要的组件之一，它负责管理线程池及任务调度。与传统的手动创建线程相比，Executor框架可以有效减少线程创建和销毁的开销，提高任务执行效率。

2.1.1 Executor接口

Executor接口是一个简单的接口，定义了一个方法void execute(Runnable command)，用于提交一个Runnable任务。通过该接口，开发者可以通过线程池来提交任务，而不必直接创建和管理线程。

2.1.2 ExecutorService接口

ExecutorService继承了Executor接口，增加了更多与任务生命周期相关的方法。ExecutorService接口允许开发者提交Callable任务，并返回一个Future对象，可以获取任务执行的结果。

常见的ExecutorService实现类有：

• ThreadPoolExecutor：最常用的线程池实现类，支持动态调整线程池的大小。
• ScheduledThreadPoolExecutor：支持定时和周期性任务的线程池。
• Executors：一个工厂类，提供创建常用线程池的静态方法，如固定大小线程池、单线程池、可缓存线程池等。

2.1.2.1 线程池的使用

import java.util.concurrent.*;public class ExecutorServiceExample {public static void main(String[] args) {// 创建一个固定大小的线程池ExecutorService executor = Executors.newFixedThreadPool(3);// 提交一个任务executor.submit(() -> {System.out.println("Task is being executed by thread: " + Thread.currentThread().getName());});// 关闭线程池executor.shutdown();}
}

在这个例子中，我们通过Executors.newFixedThreadPool(3)创建了一个包含三个线程的线程池。通过调用submit()方法，我们将一个任务提交给线程池执行。

2.2 ReentrantLock

ReentrantLock是java.util.concurrent.locks包中的一个重要类，它实现了Lock接口，提供了比synchronized更加灵活的锁机制。通过ReentrantLock，开发者可以显式地控制锁的获取和释放，避免了synchronized带来的潜在问题，如死锁。

2.2.1 基本用法

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockExample {private int count = 0;private final Lock lock = new ReentrantLock();public void increment() {lock.lock(); // 获取锁try {count++;} finally {lock.unlock(); // 确保释放锁}}public int getCount() {return count;}
}

在这个例子中，我们使用ReentrantLock代替synchronized来保证线程安全。通过显式地调用lock.lock()和lock.unlock()，我们能更灵活地控制锁的使用，避免潜在的死锁问题。

2.2.2 可重入性

ReentrantLock的一个特点是它是可重入的，这意味着同一线程可以多次获取同一个锁，而不会发生死锁。

Lock lock = new ReentrantLock();
lock.lock(); // 第一次获取锁
lock.lock(); // 第二次获取锁
// 执行操作
lock.unlock(); // 第一次释放锁
lock.unlock(); // 第二次释放锁

2.3 Semaphore

Semaphore是一个用来控制同时访问某个特定资源的线程数量的类。它通过维护一个计数器来控制最大并发线程数，常用于限制资源的并发访问。例如，数据库连接池、限流器等场景。

2.3.1 基本用法

import java.util.concurrent.*;public class SemaphoreExample {private static final Semaphore semaphore = new Semaphore(3); // 最多允许3个线程访问public static void main(String[] args) {for (int i = 0; i < 5; i++) {new Thread(() -> {try {semaphore.acquire(); // 请求许可System.out.println(Thread.currentThread().getName() + " is accessing the resource");Thread.sleep(1000); // 模拟访问资源} catch (InterruptedException e) {e.printStackTrace();} finally {semaphore.release(); // 释放许可System.out.println(Thread.currentThread().getName() + " released the resource");}}).start();}}
}

在这个例子中，Semaphore被设置为最多允许3个线程同时访问资源。每个线程在访问资源时通过acquire()方法请求许可，访问完成后通过release()方法释放许可。这样，最多只有3个线程可以同时访问共享资源。

2.4 CountDownLatch

CountDownLatch是一个同步辅助工具，它允许一个或多个线程一直等待，直到其他线程完成一组操作后再继续执行。CountDownLatch通常用于等待多个线程完成某些任务后，再执行后续的操作。

2.4.1 基本用法

import java.util.concurrent.*;public class CountDownLatchExample {public static void main(String[] args) throws InterruptedException {int taskCount = 3;CountDownLatch latch = new CountDownLatch(taskCount); // 初始化CountDownLatchfor (int i = 0; i < taskCount; i++) {final int taskId = i + 1;new Thread(() -> {try {Thread.sleep(1000); // 模拟任务System.out.println("Task " + taskId + " completed");latch.countDown(); // 每完成一个任务，调用countDown()方法} catch (InterruptedException e) {e.printStackTrace();}}).start();}latch.await(); // 主线程在这里等待，直到countDown()的调用次数为0System.out.println("All tasks are completed. Main thread can proceed.");}
}

在这个示例中，CountDownLatch用于等待3个子线程完成任务。主线程调用latch.await()阻塞，直到所有子线程完成任务并调用countDown()。一旦计数器达到0，主线程继续执行。

2.5 CyclicBarrier

CyclicBarrier是一个同步辅助工具，允许一组线程互相等待，直到所有线程都到达某个公共屏障点。CyclicBarrier可以用来实现多线程并行计算的场景，在所有线程都完成某个任务之后再开始下一阶段的工作。

2.5.1 基本用法

import java.util.concurrent.*;public class CyclicBarrierExample {public static void main(String[] args) throws InterruptedException {int threadCount = 3;CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> {System.out.println("All threads have reached the barrier, resuming...");});for (int i = 0; i < threadCount; i++) {final int taskId = i + 1;new Thread(() -> {try {Thread.sleep(1000); // 模拟工作System.out.println("Thread " + taskId + " is ready");barrier.await(); // 等待其他线程到达屏障} catch (InterruptedException | BrokenBarrierException e) {e.printStackTrace();}}).start();}}
}

在这个例子中，CyclicBarrier创建了一个屏障，所有线程都需要在barrier.await()处等待，直到所有线程都到达屏障点，之后才会继续执行。CyclicBarrier的一个特点是可以重复使用，所以它是“可循环”的。

2.6 BlockingQueue

BlockingQueue是java.util.concurrent包中的一个接口，它用于解决生产者-消费者问题。BlockingQueue提供了线程安全的插入、删除和访问操作，当队列满时，生产者会被阻塞，直到有空间；当队列空时，消费者会被阻塞，直到有数据。

常用的BlockingQueue实现类有：

• ArrayBlockingQueue：基于数组的有界队列。
• LinkedBlockingQueue：基于链表的可选有界或无界队列。
• PriorityBlockingQueue：支持优先级的无界队列。

2.6.1 基本用法

import java.util.concurrent.*;public class BlockingQueueExample {public static void main(String[] args) throws InterruptedException {BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);// 生产者线程new Thread(() -> {try {for (int i = 0; i < 10; i++) {queue.put(i); // 如果队列满，阻塞等待System.out.println("Produced: " + i);}} catch (InterruptedException e) {e.printStackTrace();}}).start();// 消费者线程new Thread(() -> {try {for (int i = 0; i < 10; i++) {Integer item = queue.take(); // 如果队列空，阻塞等待System.out.println("Consumed: " + item);}} catch (InterruptedException e) {e.printStackTrace();}}).start();}
}

在这个例子中，BlockingQueue用于实现生产者-消费者模型。生产者线程通过queue.put()方法将数据放入队列，消费者线程通过queue.take()方法从队列中取出数据。BlockingQueue提供了自动阻塞的机制，避免了竞争和数据丢失。

2.7 总结

java.util.concurrent包提供了许多强大的工具类，帮助开发者高效地处理并发编程中的各种问题。从线程池管理（Executor）到锁机制（ReentrantLock、Semaphore），从同步辅助工具（CountDownLatch、CyclicBarrier）到队列（BlockingQueue），这些工具大大简化了并发编程的复杂性，提高了程序的性能和可扩展性。

掌握这些工具类的使用，可以帮助你在并发编程中更好地控制资源、避免死锁、提高程序的并发性和响应性。

三. 死锁与锁优化

在并发编程中，死锁是一个常见且危险的问题，它可能导致程序完全停止工作。而锁优化则是为了提高程序并发性能，避免因锁竞争带来的性能瓶颈。理解死锁的成因、如何避免死锁以及如何优化锁的使用，能够帮助开发者编写更加高效且健壮的并发代码。

3.1 死锁的概念

死锁（Deadlock）是指多个线程在执行过程中，由于竞争资源并且形成循环等待，从而导致线程无法继续执行的状态。死锁会使得程序中的某些线程永远处于阻塞状态，进而使得整个系统的功能受到影响，甚至完全停滞。

3.1.1 死锁的四个必要条件

死锁的发生需要满足以下四个条件：

1. 互斥条件：至少有一个资源是以排他方式分配的，即某一时刻，只有一个线程能够使用该资源。
2. 占有并等待：至少有一个线程持有一个资源，并等待获取其他线程持有的资源。
3. 不剥夺：已经分配给线程的资源，在没有使用完之前，不能被其他线程强制剥夺。
4. 循环等待：存在一个线程等待资源的循环，换句话说，线程1等待线程2持有的资源，线程2等待线程3持有的资源，直到线程N等待线程1持有的资源，形成闭环。

3.1.2 死锁的示例

以下是一个经典的死锁示例，两个线程通过不同的顺序获取两个资源，导致互相等待，最终发生死锁。

public class DeadlockExample {private final Object lock1 = new Object();private final Object lock2 = new Object();public void method1() {synchronized (lock1) {System.out.println(Thread.currentThread().getName() + " locked lock1");try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock2) {System.out.println(Thread.currentThread().getName() + " locked lock2");}}}public void method2() {synchronized (lock2) {System.out.println(Thread.currentThread().getName() + " locked lock2");try { Thread.sleep(100); } catch (InterruptedException e) {}synchronized (lock1) {System.out.println(Thread.currentThread().getName() + " locked lock1");}}}public static void main(String[] args) {DeadlockExample deadlock = new DeadlockExample();Thread t1 = new Thread(deadlock::method1);Thread t2 = new Thread(deadlock::method2);t1.start();t2.start();}
}

在这个例子中，method1()和method2()分别锁定lock1和lock2，并且在等待对方持有的锁时发生死锁。当Thread-1在执行method1()时锁定了lock1并尝试获取lock2，而Thread-2则在执行method2()时锁定了lock2并尝试获取lock1。这导致两个线程相互等待，无法继续执行。

3.2 死锁的预防与解决

3.2.1 死锁的预防策略

为了避免死锁的发生，可以采取以下几种预防措施：

1. 避免锁嵌套：尽量避免在一个锁内再次请求其他锁。避免多个锁的嵌套调用是减少死锁风险的有效手段。

2. 获取锁的顺序一致：如果多个线程需要获取多个锁，保证所有线程按照相同的顺序来请求锁。这样就避免了因不同线程以不同顺序获取锁而造成的死锁。

   // 保证所有线程都按相同顺序请求锁
   synchronized (lock1) {synchronized (lock2) {// 处理任务}
   }
   

3. 使用tryLock()避免阻塞：ReentrantLock提供的tryLock()方法允许线程在请求锁时指定等待时间，如果在规定时间内未能获取锁，线程会放弃尝试而不再阻塞。通过这种方式，可以避免长时间的资源等待，减少死锁发生的概率。

   Lock lock1 = new ReentrantLock();
   Lock lock2 = new ReentrantLock();if (lock1.tryLock() && lock2.tryLock()) {try {// 执行任务} finally {lock1.unlock();lock2.unlock();}
   } else {// 无法获得锁，处理失败逻辑
   }
   

3.2.2 死锁的检测与恢复

在复杂的并发应用中，死锁有时是难以完全避免的，特别是当涉及到多个资源和复杂的线程交互时。为了解决死锁问题，可以采取以下方法：

1. 检测死锁：Java的ThreadMXBean可以用来检测死锁。通过调用ThreadMXBean.findDeadlockedThreads()方法，我们可以检测系统中的死锁情况并采取相应的措施。

   import java.lang.management.*;public class DeadlockDetection {public static void main(String[] args) {ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();if (deadlockedThreads != null) {System.out.println("Deadlock detected!");// 处理死锁：例如打印死锁线程信息并终止线程}}
   }
   

2. 恢复策略：当死锁发生时，可以采用如下策略：

   • 终止线程：强制中止某些线程，释放其持有的锁，打破死锁。
   • 重试机制：如果检测到死锁，程序可以重试请求锁的过程，或者根据设定的超时机制放弃。

3.3 锁优化

3.3.1 锁粒度与锁竞争

锁的粒度影响着并发程序的性能。如果锁的粒度过大，比如将整个方法加锁，可能会导致不必要的线程等待。而如果锁的粒度过小，可能会增加锁竞争的概率，导致性能问题。为了优化锁的使用，应该根据任务的性质合理地选择锁的粒度。

1. 细化锁粒度：尽量将锁的范围限制在关键代码段，以减少锁的持有时间。

   // 锁粒度过大，整个方法都被同步
   public synchronized void processData() {// 执行处理
   }// 锁粒度适当缩小，只同步必要的代码
   public void processData() {synchronized (lock) {// 执行关键操作}
   }
   

2. 减少锁竞争：减少不同线程同时竞争同一资源的概率。例如，可以使用读写锁（ReadWriteLock），允许多个线程并行读取共享资源，只有在写操作时才会互斥。

3.3.2 使用ReentrantLock进行锁优化

ReentrantLock提供了比synchronized更灵活的锁控制，它可以显式地尝试获取锁，控制锁的获取时间，从而避免死锁和锁竞争问题。

• 公平锁：ReentrantLock支持公平锁机制，即按照线程请求锁的顺序来获取锁，这可以减少资源的争抢。

  Lock lock = new ReentrantLock(true); // 公平锁
  

• 可重入性：ReentrantLock是可重入的，即同一线程可以多次获取同一把锁。可以通过lock.lock()和lock.unlock()明确控制锁的获取和释放。

• 中断响应：ReentrantLock支持响应中断，允许线程在等待锁的过程中被中断，这对于避免长时间等待产生的死锁具有重要意义。

  Lock lock = new ReentrantLock();
  try {if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {// 执行任务} else {// 处理无法获得锁的情况}
  } catch (InterruptedException e) {// 响应中断
  }
  

3.3.3 读写锁优化

在读多写少的场景中，可以使用ReadWriteLock，这能显著提高并发性能。ReadWriteLock通过将读锁和写锁分开管理，允许多个线程并行读取，而写线程则需要独占访问资源，从而提高了系统的吞吐量。

ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
try {// 执行读取操作
} finally {lock.readLock().unlock();
}lock.writeLock().lock();
try {// 执行写操作
} finally {lock.writeLock().unlock();
}

3.4 小结

死锁是多线程编程中的常见问题，其发生通常是由于资源的竞争和线程之间不当的锁管理引起的。通过合理设计锁的获取顺序、避免锁嵌套、使用tryLock()等方法，可以有效减少死锁的发生。而在优化锁的使用时，合理选择锁粒度、使用ReentrantLock、ReadWriteLock等工具类，可以大幅提高并发程序的性能。

开发者需要时刻关注死锁的可能性，并在开发过程中采取相应的预防措施。此外，合理使用锁优化技术，将帮助我们在保证线程安全的同时，提高系统的并发能力和性能。

四. 总结

在Java中，锁和原子操作是保证多线程并发安全的重要工具。从基础的synchronized到更灵活的ReentrantLock、ReadWriteLock，以及高效的Atomic类，它们各自有不同的使用场景和特点。通过合理使用这些工具，开发者可以保证线程安全并提高程序的性能。

在实际开发中，我们不仅要关注锁的正确使用，还需要避免死锁，合理优化锁的粒度和范围，确保并发程序既安全又高效。掌握这些并发工具，将有助于你在多线程编程的道路上走得更远。