【多线程】（二）线程安全问题与线程同步

**多线程（二）：线程安全问题与线程同步**

在上一篇文章中，我们讨论了多线程的基本概念、创建线程的方法以及线程的生命周期。然而，在实际开发中，多线程编程往往会遇到一些复杂的问题，例如线程安全问题和线程同步问题。

**线程安全问题**

线程安全问题是指在多线程环境下，程序可能出现的错误或异常情况，这些错误通常与共享资源的访问有关。共享资源可以是变量、数据结构或者其他任何能够被多个线程访问的对象。

###例子：不安全的计数器

javapublic class UnsafeCounter {
 private int count =0;

 public void increment() {
 count++;
 }

 public static void main(String[] args) throws InterruptedException {
 UnsafeCounter counter = new UnsafeCounter();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 counter.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 counter.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println("Final count: " + counter.count);
 }
}

在这个例子中，我们创建了一个不安全的计数器类 `UnsafeCounter`，它使用一个共享变量 `count` 来存储计数值。在 `main` 方法中，我们启动两个线程，每个线程都执行10,000 次 `increment` 操作。由于线程之间没有任何同步机制，因此可能会出现多次加法操作被覆盖的问题，导致最终的计数值小于预期。

### 解决方案：使用锁要解决这个问题，我们可以使用 Java 中的 `synchronized` 关键字来保护共享变量 `count`。我们将 `increment` 方法标记为 `synchronized`，这样只有一个线程能够访问该方法。

javapublic class SafeCounter {
 private int count =0;

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

 // ...
}

通过使用锁，我们可以确保在多线程环境下，共享变量 `count` 的访问是安全的。每次只有一个线程能够执行 `increment` 操作，因此不会出现加法操作被覆盖的问题。

###例子：使用 ReentrantLock除了使用 `synchronized` 关键字之外，我们还可以使用 Java 中的 `ReentrantLock` 类来实现锁机制。下面是一个使用 `ReentrantLock` 的例子：

javaimport java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
 private int count =0;
 private final ReentrantLock lock = new ReentrantLock();

 public void increment() {
 lock.lock();
 try {
 count++;
 } finally {
 lock.unlock();
 }
 }

 // ...
}

在这个例子中，我们使用 `ReentrantLock` 来保护共享变量 `count`。每次我们需要访问 `count` 时，都会先锁住 `lock`，然后执行加法操作，最后再解锁 `lock`。

**线程同步问题**

线程同步问题是指在多线程环境下，程序可能出现的错误或异常情况，这些错误通常与共享资源的访问有关。共享资源可以是变量、数据结构或者其他任何能够被多个线程访问的对象。

###例子：不安全的计数器（再次）

javapublic class UnsafeCounter {
 private int count =0;

 public void increment() {
 // 假设有一个线程正在执行加法操作 if (count ==10000) {
 System.out.println("Count reached10,000!");
 return;
 }
 count++;
 }

 public static void main(String[] args) throws InterruptedException {
 UnsafeCounter counter = new UnsafeCounter();
 Thread thread1 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 counter.increment();
 }
 });
 Thread thread2 = new Thread(() -> {
 for (int i =0; i < 10000; i++) {
 counter.increment();
 }
 });

 thread1.start();
 thread2.start();

 thread1.join();
 thread2.join();

 System.out.println("Final count: " + counter.count);
 }
}

在这个例子中，我们创建了一个不安全的计数器类 `UnsafeCounter`，它使用一个共享变量 `count` 来存储计数值。在 `main` 方法中，我们启动两个线程，每个线程都执行10,000 次 `increment` 操作。由于线程之间没有任何同步机制，因此可能会出现多次加法操作被覆盖的问题，导致最终的计数值小于预期。

### 解决方案：使用锁要解决这个问题，我们可以使用 Java 中的 `synchronized` 关键字来保护共享变量 `count`。我们将 `increment` 方法标记为 `synchronized`，这样只有一个线程能够访问该方法。

javapublic class SafeCounter {
 private int count =0;

 public synchronized void increment() {
 // 假设有一个线程正在执行加法操作 if (count ==10000) {
 System.out.println("Count reached10,000!");
 return;
 }
 count++;
 }

 // ...
}

通过使用锁，我们可以确保在多线程环境下，共享变量 `count` 的访问是安全的。每次只有一个线程能够执行 `increment` 操作，因此不会出现加法操作被覆盖的问题。

###例子：使用 ReentrantLock除了使用 `synchronized` 关键字之外，我们还可以使用 Java 中的 `ReentrantLock` 类来实现锁机制。下面是一个使用 `ReentrantLock` 的例子：

javaimport java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
 private int count =0;
 private final ReentrantLock lock = new ReentrantLock();

 public void increment() {
 lock.lock();
 try {
 // 假设有一个线程正在执行加法操作 if (count ==10000) {
 System.out.println("Count reached10,000!");
 return;
 }
 count++;
 } finally {
 lock.unlock();
 }
 }

 // ...
}

在这个例子中，我们使用 `ReentrantLock` 来保护共享变量 `count`。每次我们需要访问 `count` 时，都会先锁住 `lock`，然后执行加法操作，最后再解锁 `lock`。

**总结**

线程安全问题和线程同步问题是多线程编程中常见的问题。在本文中，我们讨论了不安全的计数器例子，并使用 Java 中的 `synchronized` 关键字和 `ReentrantLock` 类来解决这些问题。通过使用锁机制，我们可以确保在多线程环境下，共享变量的访问是安全的。