15. 线程安全-优快云博客

本文链接：https://blog.youkuaiyun.com/sinat_33739100/article/details/147479967

线程安全 是指在多线程环境下，程序能够正确处理共享资源的访问，确保数据的一致性和正确性。当多个线程并发访问共享资源时，如果没有适当的同步机制，可能会导致数据不一致、程序崩溃或其他不可预期的行为。

1. 线程不安全的原因

线程不安全通常是由于以下原因导致的：

竞态条件（Race Condition）：多个线程同时访问和修改共享资源，导致结果依赖于线程执行的顺序。
数据竞争（Data Race）：多个线程同时读写共享变量，且没有正确的同步机制。
可见性问题：一个线程对共享变量的修改可能对其他线程不可见，导致读取到过期的数据。

2. 线程安全的实现方式

为了实现线程安全，可以采用以下方法：

（1）使用同步机制

synchronized 关键字：

通过锁机制确保同一时间只有一个线程可以访问共享资源。
可以修饰方法或代码块。

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

ReentrantLock：

比 synchronized 更灵活的锁机制，支持公平锁、可中断锁等。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

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

（2）使用线程安全的类

Java 提供了许多线程安全的类，例如：

AtomicInteger、AtomicLong 等原子类。
ConcurrentHashMap、CopyOnWriteArrayList 等并发集合。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

（3）使用不可变对象

不可变对象（Immutable Object）是线程安全的，因为它们的状态在创建后不能被修改。

例如：String、Integer 等。

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

（4）使用线程局部变量（ThreadLocal）

ThreadLocal 可以为每个线程创建独立的变量副本，避免共享资源。

public class ThreadLocalExample {
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void increment() {
        threadLocal.set(threadLocal.get() + 1);
    }

    public int getValue() {
        return threadLocal.get();
    }
}

（5）使用 volatile 关键字

volatile 确保变量的可见性，但不保证原子性。

适用于只有一个线程写、多个线程读的场景。

public class VolatileExample {
    private volatile boolean flag = false;

    public void toggleFlag() {
        flag = !flag;
    }

    public boolean isFlag() {
        return flag;
    }
}

3. 线程安全的级别

根据线程安全的程度，可以分为以下几类：

不可变（Immutable）：绝对线程安全，例如 String。
绝对线程安全：在任何操作下都线程安全，例如 CopyOnWriteArrayList。
相对线程安全：对单个操作是线程安全的，但复合操作可能需要额外同步，例如 Vector。
非线程安全：需要外部同步机制，例如 ArrayList、HashMap。

4. 线程安全的测试

可以通过多线程环境下的压力测试来验证线程安全性。例如：

public class ThreadSafetyTest {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // 应该输出 2000
    }
}