Java多线程之线程安全问题详情

什么是线程安全问题？

在多线程并发执行的过程中，若多个线程会同时访问同一个共享的数据，就有可能出现线程安全问题。

这种问题常见的形式就是多个线程操作同一份数据时，会产生竞态条件（Race Condition），导致数据的状态被破坏。

线程安全问题包括但不限于：

• 数据竞争（Data Race）
• 重入锁问题（Reentrant Lock Issue）
• 死锁（Deadlock）
• 饥饿（Starvation）等。

如何解决线程安全问题？

为了解决线程安全问题，我们通常采用以下三种方法：

1. 同步方法（Synchronized Methods）

我们可以通过加锁来实现对共享变量的互斥访问，也就是在方法前面添加synchronized关键字，示例代码如下：

public synchronized void increament() {
    count++; // count为共享变量
}

1. 同步代码块（Synchronized Blocks）

同步代码块是指在方法内部嵌套一个同步代码块，在这个代码块内部完成对共享数据的访问。示例代码如下：

public void increament() {
    synchronized (this) {
        count++; // count为共享变量
    }
}

1. 锁机制（Lock Mechnisms）

Lock机制可替代synchronized关键字，使用起来更加灵活，且提供更多的控制和锁定的机制。示例代码如下：

private Lock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count++; // count为共享变量
    } finally {
        lock.unlock();
    }
}

线程安全问题案例分析

数据竞争问题案例

当多个线程同时对一个变量进行修改时，就会发生数据竞争的问题。

示例代码：

public class DataRaceExample {
   public static void main(String[] args) {
      Counter counter = new Counter();
      Runnable runnable = () -> {
         for (int i = 0; i < 10000; i++) {
            counter.increament();
         }
      };
      Thread thread1 = new Thread(runnable);
      Thread thread2 = new Thread(runnable);
      thread1.start();
      thread2.start();
      try {
         thread1.join();
         thread2.join();
         System.out.println(counter.getCount());
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
   }
}

public class Counter {
   private int count = 0;

   public void increament() {
      count++;
   }

   public int getCount() {
      return count;
   }
}

在上面的例子中，Counter类中的共享变量count被同时访问，并且没有进行同步处理，导致数据竞争的问题。

死锁问题案例

当多个线程在等待某个资源时，又持有其他线程需要的资源，就会发生死锁的问题。

示例代码：

public class DeadlockExample {
   public static void main(String[] args) {
      Object resource1 = new Object();
      Object resource2 = new Object();
      Thread thread1 = new Thread(() -> {
         synchronized (resource1) {
            System.out.println("Thread 1: Locked resource 1");
            try {
               Thread.sleep(1000);
            } catch (InterruptedException ex) {
               ex.printStackTrace();
            }
            synchronized (resource2) {
               System.out.println("Thread 1: Locked resource 2");
            }
         }
      });
      Thread thread2 = new Thread(() -> {
         synchronized (resource2) {
            System.out.println("Thread 2: Locked resource 2");
            try {
               Thread.sleep(1000);
            } catch (InterruptedException ex) {
               ex.printStackTrace();
            }
            synchronized (resource1) {
               System.out.println("Thread 2: Locked resource 1");
            }
         }
      });
      thread1.start();
      thread2.start();
   }
}

在上面的例子中，Thread 1持有resource1，等待获取resource2，Thread 2持有resource2，等待获取resource1，互相等待导致死锁问题。