Java 什么是线程安全及如何实现线程安全

1. 什么是线程安全？

线程安全 指的是在多线程环境下，某个类、方法或对象能够正确、一致地处理共享数据，无需额外的同步机制即可保证：

• 原子性（Atomicity）：操作不可分割，要么全部完成，要么全部不执行。

• 可见性（Visibility）：一个线程修改共享变量后，其他线程能立即看到最新值。

• 有序性（Ordering）：代码执行顺序符合预期，避免指令重排序导致的逻辑错误。

线程不安全的典型表现：

• 数据竞争（Data Race）：多线程同时修改共享变量导致结果不可预测。

• 脏读（Dirty Read）：读取到其他线程未完成的中间状态数据。

• 死锁（Deadlock）：多个线程互相等待对方释放锁，导致永久阻塞。

---

2. Java 中如何实现线程安全？

以下是 Java 中实现线程安全的 7 种核心方法，每种方法均附有代码示例和适用场景。

---

2.1 使用 synchronized 关键字

原理：通过 JVM 内置锁（Monitor）实现互斥访问，确保同一时间只有一个线程执行临界区代码。
示例：

java

复制

public class Counter {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void incrementWithBlock() {
        synchronized (this) {
            count++;
        }
    }
}

适用场景：

• 简单的同步需求（如单例模式、计数器）。

• 对性能要求不高，优先保证代码简洁性。

---

2.2 使用 ReentrantLock 显式锁

原理：基于 java.util.concurrent.locks.ReentrantLock，提供比 synchronized 更灵活的锁控制（如可中断、超时、公平锁）。
示例：

java

复制

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

适用场景：

• 需要高级锁功能（如 tryLock()、lockInterruptibly()）。

• 高并发场景下的细粒度锁控制。

---

2.3 使用原子类（Atomic Classes）

原理：基于 CAS（Compare-and-Swap）实现无锁线程安全操作，适用于简单原子操作。
示例：

java

复制

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // 原子递增
    }
}

适用场景：

• 单一变量的原子操作（如计数器、标志位）。

• 低竞争场景，避免锁开销。

---

2.4 使用 volatile 关键字

原理：保证变量的可见性和禁止指令重排序，但不保证原子性。
示例：

java

复制

public class VolatileExample {
    private volatile boolean flag = false;
    
    public void toggleFlag() {
        flag = !flag; // 非原子操作，需配合 synchronized 或原子类使用
    }
}

适用场景：

• 状态标志（如开关控制），一写多读场景。

• 配合其他机制（如 synchronized）保证复合操作的原子性。

---

2.5 使用不可变对象（Immutable Objects）

原理：对象创建后状态不可变，天然线程安全。
示例：

java

复制

public final class ImmutablePerson {
    private final String name;
    private final int age;
    
    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 无 setter 方法
    public String getName() { return name; }
    public int getAge() { return age; }
}

适用场景：

• 配置信息、常量等只读数据。

• 避免深拷贝或防御性拷贝的开销。

---

2.6 使用线程封闭（Thread Confinement）

原理：通过 ThreadLocal 为每个线程创建独立的变量副本，避免共享。
示例：

java

复制

public class UserContext {
    private static ThreadLocal<User> userHolder = new ThreadLocal<>();
    
    public static void setUser(User user) {
        userHolder.set(user);
    }
    
    public static User getUser() {
        return userHolder.get();
    }
}

适用场景：

• 用户会话、数据库连接等线程隔离数据。

• 避免传递参数的繁琐性。

---

2.7 使用并发容器（Concurrent Collections）

原理：Java 提供线程安全的集合类，内部已实现同步机制。
示例：

java

复制

public class Cache {
    private ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
    
    public void put(String key, Object value) {
        map.put(key, value);
    }
    
    public Object get(String key) {
        return map.get(key);
    }
}

适用场景：

• 高并发环境下的数据存储（如缓存、任务队列）。

• 替代 Collections.synchronizedXXX() 提升性能。

---

3. 线程安全实现对比表

方法	优点	缺点	适用场景
synchronized	简单、自动释放锁	功能单一、性能中等	简单同步需求
ReentrantLock	灵活（超时、中断、公平锁）	需手动释放锁，代码复杂	高并发、需要高级锁功能
原子类	无锁、高性能	仅支持单一变量原子操作	计数器、标志位
volatile	轻量级可见性保证	不保证原子性	状态标志、配合其他机制使用
不可变对象	天然线程安全	需要创建新对象	配置信息、常量
ThreadLocal	线程隔离、无竞争	内存泄漏风险	用户会话、线程上下文
并发容器	高性能、内置同步	功能受限	高并发集合操作

---

4. 常见面试问题示例

Q1：synchronized 和 ReentrantLock 的区别？

• synchronized 是 JVM 内置锁，自动释放；ReentrantLock 是 API 级锁，需手动释放。

• ReentrantLock 支持可中断、超时、公平锁，synchronized 不支持。

Q2：volatile 能替代 synchronized 吗？

• 不能。volatile 仅保证可见性和有序性，不保证原子性。例如 volatile int i = 0; i++ 是非原子操作。

Q3：如何设计一个线程安全的单例模式？

• 双重检查锁（DCL） + volatile：

  java

  复制

  public class Singleton {
      private static volatile Singleton instance;
      
      private Singleton() {}
      
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }

---

总结

实现线程安全的核心在于 控制共享数据的访问，具体方法需根据场景选择：

• 简单同步 → synchronized

• 高性能无锁 → 原子类

• 复杂控制 → ReentrantLock

• 状态标志 → volatile

• 数据隔离 → ThreadLocal

• 高并发集合 → 并发容器

理解线程安全的三要素（原子性、可见性、有序性）是解决多线程问题的关键。

测试用例：

package com.example.MySpringBootTest.test.threadsafe;

import java.util.ArrayList;
import java.util.List;

public class ThreadSafeExample {
    public static void main(String[] args) throws InterruptedException {
        List<Integer> list = new ArrayList<>();
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 1000; i++) {
                    list.add(i);

                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                for (int i = 0; i < 500; i++) {
                    if (!list.isEmpty()) {
                        list.remove(0);
                    }
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });

        thread.start();
        thread1.start();

        thread.join();
        thread1.join();

        System.out.println("列表最终大小: " + list.size());
    }
}

当没有用 synchronized 做锁排序时候，列表最终大小: 经常不等于500，浮现了非线程安全。加锁后，对并发线程做了串行化，列表最终大小: 500。