什么是线程安全，怎么保证线程安全

线程安全是一个多线程编程中的核心概念。当多个线程访问某个类、对象或方法时，如果程序不需要进行额外的同步控制或协调，而这个类、对象或方法总能表现出正确的行为（即其执行结果与预期一致，并且不会出现数据损坏、状态不一致等问题），那么我们就称它是线程安全的。

简单来说，如果一段代码在并发环境下执行的结果和在单线程环境下执行的结果一致，并且不会引入额外的错误，那么它就是线程安全的。

线程不安全的根本原因在于多个线程对共享资源（也称为临界资源，如共享变量、共享数据结构、文件等）的并发访问，特别是当至少有一个访问是写操作时，如果没有适当的同步机制，就可能导致竞态条件 (Race Condition)、数据不一致、死锁等问题。

保证线程安全主要有以下几种方法和策略：

  1. 避免共享资源： 这是最彻底的方法。如果线程之间不共享任何数据，或者共享的数据都是不可变的，那么自然就不会有线程安全问题。

    • 线程本地存储 (ThreadLocal Storage)：为每个线程创建一份变量的副本，线程各自操作自己的副本，互不影响。例如，Java中的ThreadLocal类。
    • 不可变对象 (Immutable Objects)：一旦对象被创建，其内部状态就不能再被修改。所有对不可变对象的访问都是只读的，因此它们天然是线程安全的。例如，Java中的String类、基本数据类型的包装类（Integer, Long等，但要注意它们提供的valueOf方法有缓存）。设计自定义不可变对象时，要确保所有字段都是final的，并且不提供修改内部状态的方法。如果包含可变对象的引用，要确保这些对象不会被外部修改或者进行深拷贝保护。

  2. 使用同步机制： 当必须共享可变资源时，需要使用同步机制来控制对共享资源的访问，确保在任意时刻只有一个线程（或有限个线程，如读写锁的读操作）可以修改或访问该资源。

    • 互斥锁 (Mutex / Locks)：
      • synchronized关键字 (Java)：可以修饰方法或代码块。它依赖JVM实现的内置锁（也叫监视器锁）。
      • java.util.concurrent.locks.Lock接口及其实现类 (如 ReentrantLock)：提供了比synchronized更灵活的锁操作，如可中断锁、超时锁、公平锁/非公平锁选择等。
      • 读写锁 (ReadWriteLock, 如 ReentrantReadWriteLock)：允许多个读线程同时访问，但写线程访问时会互斥。适用于读多写少的场景。
    • 信号量 (Semaphore)：控制同时访问特定资源的线程数量。
    • 原子操作 (Atomic Operations)：对于简单的计数、标志位更新等操作，可以使用原子类（如Java中的java.util.concurrent.atomic包下的AtomicInteger, AtomicBoolean等）。它们利用了CPU提供的CAS (Compare-And-Swap) 指令等硬件级别的原子性保证，通常比使用锁的开销更小。

  3. 使用线程安全的数据结构： 许多编程语言的标准库都提供了线程安全的集合类或数据结构。

    • Java中的并发容器：
      • ConcurrentHashMap：线程安全的哈希表，分段锁（JDK 1.7及之前）或CAS+Node锁（JDK 1.8及之后）技术，性能远优于Collections.synchronizedMap(new HashMap<>())。
      • CopyOnWriteArrayList / CopyOnWriteArraySet：写时复制容器。写操作时会创建一个底层数组的副本进行修改，读操作则访问原始数组，无锁。适用于读多写少的场景，写操作开销较大。
      • BlockingQueue接口及其实现类 (如 ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue)：阻塞队列，常用于生产者-消费者模式，它们内部处理了同步问题。

  4. 保证操作的原子性： 如果一个操作包含多个步骤，而这些步骤必须作为一个不可分割的整体执行，就需要保证其原子性。

    • 使用锁来保护复合操作。
    • 利用CAS操作实现无锁的原子更新。

  5. 保证内存可见性 (Visibility)： 当一个线程修改了共享变量的值，其他线程能够立即看到这个修改。

    • volatile关键字 (Java)：保证被修饰变量的修改对所有线程立即可见，并禁止指令重排序优化。它不保证原子性（除了对long和double的64位写操作的原子性，以及对单个volatile变量的读写本身是原子的）。
    • synchronized和Lock：不仅保证原子性，也保证可见性。当一个线程释放锁时，会将工作内存中的修改刷新到主内存；当一个线程获取锁时，会使工作内存中的缓存失效，从主内存重新加载。
    • final关键字：被final修饰的字段在构造函数中一旦初始化完成，并且构造函数没有把this引用泄露出去，那么其他线程就能看到final字段的正确初始化值。

  6. 保证有序性 (Ordering)： 程序执行的顺序按照代码的先后顺序执行（在单线程看来是这样，但编译器和处理器可能会进行指令重排序以优化性能）。

    • volatile关键字：禁止指令重排序。
    • synchronized和Lock：一个锁的释放操作 (unlock) happens-before 于后续对这个锁的获取操作 (lock)。
    • Happens-before原则：Java内存模型 (JMM) 定义了一系列happens-before规则，如程序顺序规则、监视器锁规则、volatile变量规则、线程启动规则、线程终止规则、线程中断规则、对象终结规则、传递性。如果两个操作之间存在happens-before关系，那么第一个操作的结果对第二个操作可见，并且第一个操作的执行顺序在第二个操作之前。

选择哪种方法取决于具体的场景：

  • 如果数据是只读的或者线程隔离的，那么选择“避免共享”是最优的。
  • 如果需要共享可变数据，优先考虑使用线程安全的并发容器。
  • 对于复杂的操作，需要使用锁或其他同步原语来保证原子性和可见性。
  • volatile适用于简单的状态标志或单个变量的可见性保证，但不能替代锁来保证复合操作的原子性。

拓展延申：

  1. 线程安全的级别： 可以对线程安全进行更细致的划分：

    • 不可变 (Immutable)：对象创建后状态不能改变，天然线程安全。
    • 绝对线程安全 (Absolutely Thread-Safe)：无论运行时环境如何，调用者都不需要任何额外的同步措施。Java中很少有绝对线程安全的类。
    • 相对线程安全 (Relatively Thread-Safe)：通常我们说的线程安全指的是这种，单个操作是线程安全的，但对于某些特定的连续调用序列，可能需要调用者进行额外的同步。例如Vector的add和get方法是同步的，但如果你先检查isEmpty再get，这个组合操作不是原子的，需要外部同步。
    • 线程兼容 (Thread-Compatible)：对象本身不是线程安全的，但可以通过在调用端正确地使用同步手段来保证并发环境下的安全使用。例如ArrayList, HashMap。
    • 线程对立 (Thread-Hostile)：即使调用端使用了同步手段，也无法安全并发使用的代码。这种情况比较少见，通常是由于代码本身有严重缺陷。

  2. 无锁编程 (Lock-Free Programming)： 除了传统的基于锁的同步，还有一类无锁编程技术，主要依赖CAS操作。

    • 优点：避免了锁带来的开销（如上下文切换、调度延迟），在高并发下可能获得更好的性能，并且可以避免死锁问题。
    • 缺点：实现复杂，容易出错，通常只适用于特定的数据结构和算法。ABA问题是CAS操作的一个经典问题，需要通过版本号等方式解决。

  3. 死锁、活锁、饥饿： 在追求线程安全的过程中，如果同步机制使用不当，可能会引发其他并发问题：

    • 死锁 (Deadlock)：已在之前问题中讨论过。
    • 活锁 (Livelock)：线程没有被阻塞，都在积极地响应对方，但由于某些条件相互谦让或重试，导致任务都无法继续推进。就像两个人过窄道，都想给对方让路，结果来回踱步谁也过不去。
    • 饥饿 (Starvation)：某个或某些线程由于优先级过低，或者某些资源长时间被其他高优先级线程或写线程（在读写锁场景下）占用，导致它们一直无法获得执行所需的资源，从而无法完成工作。