什么是线程安全？如何保证线程安全？

一、线程安全的定义

线程安全是指在多线程环境下，一个对象、方法或代码块能够被多个线程同时调用而不会导致数据不一致或程序行为异常的情况。线程安全的代码在并发环境下能够正确地处理共享资源，保证数据的一致性和完整性。

线程安全的核心特征

• 原子性：操作要么全部执行，要么全部不执行，不会被中断
• 可见性：一个线程对共享变量的修改，对其他线程是立即可见的
• 有序性：程序执行的顺序按照代码的顺序执行（即使有指令重排序，也不会影响单线程下的执行结果）

线程安全问题的主要原因

1. 竞态条件（Race Condition）：多个线程同时访问和修改共享数据，导致执行结果依赖于线程执行的时序
2. 可见性问题：一个线程对共享变量的修改，对其他线程可能不可见
3. 有序性问题：指令重排序可能导致程序执行顺序与代码顺序不一致

二、如何保证线程安全

1. 互斥同步（阻塞同步）

互斥同步是最常见的保证线程安全的方式，通过锁来实现同一时间只允许一个线程访问共享资源。

synchronized关键字

synchronized是Java提供的内置锁机制，可以修饰方法或代码块。

// 修饰实例方法
public synchronized void instanceMethod() {
    // 临界区代码
}

// 修饰静态方法
public static synchronized void staticMethod() {
    // 临界区代码
}

// 修饰代码块
public void blockMethod() {
    synchronized(this) { // 对象锁
        // 临界区代码
    }
    
    synchronized(ClassName.class) { // 类锁
        // 临界区代码
    }
}

ReentrantLock类

ReentrantLock是Java提供的显式锁，相比synchronized提供了更灵活的功能。

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
    
    public void method() {
        lock.lock();  // 获取锁
        try {
            // 临界区代码
        } finally {
            lock.unlock();  // 释放锁
        }
    }
}

synchronized与ReentrantLock的对比：

2. 非阻塞同步

非阻塞同步通过CAS（Compare-And-Swap）操作实现，避免了线程的阻塞和唤醒，提高了并发性能。

CAS操作

CAS包含三个操作数：内存位置（V）、预期原值（A）和新值（B）。如果内存位置V的值与预期原值A相匹配，那么处理器会自动将该位置的值更新为新值B，否则不做任何操作。

// CAS操作伪代码
public boolean compareAndSet(int expect, int update) {
    if (this.value == expect) {
        this.value = update;
        return true;
    }
    return false;
}

原子类

Java提供了一系列原子类，基于CAS操作实现线程安全。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // 原子自增
    }
    
    public int getCount() {
        return count.get();
    }
}

常用原子类包括：

• AtomicInteger、AtomicLong、AtomicBoolean：基本类型原子类
• AtomicReference：引用类型原子类
• AtomicStampedReference：带有版本号的引用类型原子类，解决ABA问题
• AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray：数组类型原子类

3. 无同步方案

不可变对象

不可变对象一旦创建就不能被修改，因此天然是线程安全的。

public final class ImmutableExample {
    private final int value;
    
    public ImmutableExample(int value) {
        this.value = value;
    }
    
    public int getValue() {
        return value;
    }
}

创建不可变对象的原则：

• 使用final修饰类，防止被继承
• 使用final修饰所有字段，确保创建后不能被修改
• 如果字段包含可变对象的引用，确保这些对象不会被外部访问和修改
• 不提供修改状态的方法

线程封闭

线程封闭是指将对象封闭在一个线程中，只有该线程才能访问此对象，从而避免多线程环境下的竞争条件。

线程封闭的实现方式：

1. Ad-hoc线程封闭：完全由程序实现来控制，不推荐
2. 栈封闭：局部变量（方法内部的变量）被封闭在执行线程的栈中
3. ThreadLocal类：每个线程都有自己独立的ThreadLocal变量副本

public class ThreadLocalExample {
    private static final ThreadLocal<SimpleDateFormat> dateFormat = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    public String format(Date date) {
        return dateFormat.get().format(date);  // 每个线程使用自己的SimpleDateFormat实例
    }
}

4. 安全发布

安全发布是指确保对象在被其他线程访问时，已经完成了正确的初始化。

安全发布的方式

1. 通过静态初始化器初始化对象：JVM保证静态初始化器的线程安全性

public static final Singleton INSTANCE = new Singleton();

2. 使用volatile关键字：保证变量的可见性和禁止指令重排序

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;
    }
}

3. 使用线程安全的容器：如ConcurrentHashMap、CopyOnWriteArrayList等

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

三、线程安全设计原则

在设计线程安全的程序时，应遵循以下原则：

1. 最小化共享数据：尽量减少线程间共享的数据量
2. 最小化同步范围：尽量缩小同步代码块的范围
3. 使用高级并发工具：优先使用Java并发包提供的高级工具类
4. 避免死锁：注意锁的获取顺序，避免循环等待
5. 考虑性能：平衡线程安全与性能，避免过度同步

四、常见线程安全问题案例分析

1. i++操作的非原子性

public class Counter {
    private int count = 0;
    
    // 非线程安全的自增操作
    public void increment() {
        count++;  // 实际包含读-改-写三步操作
    }
    
    // 线程安全的自增操作
    public synchronized void safeIncrement() {
        count++;
    }
}

2. 延迟初始化的线程安全问题

public class LazyInit {
    private Resource resource = null;
    
    // 非线程安全的延迟初始化
    public Resource getResource() {
        if (resource == null) {
            resource = new Resource();  // 可能创建多个实例
        }
        return resource;
    }
    
    // 线程安全的延迟初始化（双重检查锁定）
    private volatile Resource safeResource = null;
    
    public Resource getSafeResource() {
        if (safeResource == null) {
            synchronized (this) {
                if (safeResource == null) {
                    safeResource = new Resource();
                }
            }
        }
        return safeResource;
    }
}

通过以上内容，我们了解了线程安全的概念、问题原因以及多种保证线程安全的方法。在实际开发中，应根据具体场景选择合适的线程安全策略，平衡安全性与性能。

参考资料

1. Java并发编程实战
2. Java官方文档 - Concurrency
3. Java并发包(java.util.concurrent)详解
4. 深入理解Java内存模型