Java中实现线程安全的几种方式

原创于 2025-07-10 18:37:16 发布 · 1k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #安全 #开发语言

Java中实现线程安全的几种方式

在Java中实现线程安全是并发编程的核心问题，以下是几种主要的线程安全实现方式及其适用场景：

一、不可变对象（Immutable Objects）

原理：对象创建后状态不可改变，自然线程安全

实现方式：

// 1. 使用final修饰类和所有字段
public final class ImmutablePerson {
    private final String name;
    private final int age;
    
    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 只提供getter方法
}

// 2. 使用Collections.unmodifiableXXX创建不可变集合
List<String> list = Collections.unmodifiableList(new ArrayList<>(Arrays.asList("a", "b")));

适用场景：

配置信息
值对象
常量数据

二、同步方法（Synchronized Methods）

原理：使用内置锁（对象监视器）保证方法级别的原子性

实现方式：

public class Counter {
    private int count;
    
    // 实例方法同步 - 锁是当前实例对象
    public synchronized void increment() {
        count++;
    }
    
    // 静态方法同步 - 锁是Class对象
    public static synchronized void staticMethod() {
        // ...
    }
}

特点：

简单易用
粒度较粗（整个方法同步）
可能造成性能瓶颈

三、同步代码块（Synchronized Blocks）

原理：对关键代码段而非整个方法进行同步

实现方式：

public class FineGrainedSync {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {
            // 临界区代码
        }
    }
    
    public void method2() {
        synchronized(lock2) {
            // 另一个临界区
        }
    }
}

优点：

比同步方法更细粒度
可以使用不同的锁对象提高并发度

四、显式锁（Explicit Locks）

原理：使用java.util.concurrent.locks包中的锁实现

实现方式：

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int sharedState;
    
    public void modifySharedState() {
        lock.lock();  // 获取锁
        try {
            sharedState++;
        } finally {
            lock.unlock();  // 必须释放锁
        }
    }
}

高级特性：

可尝试获取锁（tryLock()）
可中断获取锁（lockInterruptibly()）
公平锁/非公平锁选择
多个条件变量（Condition）

五、原子变量（Atomic Variables）

原理：使用CAS（Compare-And-Swap）指令实现无锁线程安全

实现方式：

public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // 原子操作
    }
    
    public int getCount() {
        return count.get();
    }
}

常用原子类：

AtomicInteger/AtomicLong/AtomicBoolean
AtomicReference
AtomicIntegerArray等数组类型
LongAdder（高并发计数场景）

六、线程局部变量（ThreadLocal）

原理：每个线程有自己的变量副本，避免共享

实现方式：

public class ThreadLocalExample {
    private static final ThreadLocal<SimpleDateFormat> dateFormat =
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
    public String formatDate(Date date) {
        return dateFormat.get().format(date);
    }
}

适用场景：

非线程安全的类（如SimpleDateFormat）
需要保持线程隔离状态（如用户会话）

七、并发集合（Concurrent Collections）

原理：专门设计的线程安全集合类

常用实现：

// 1. ConcurrentHashMap
Map<String, String> concurrentMap = new ConcurrentHashMap<>();

// 2. CopyOnWriteArrayList
List<String> copyOnWriteList = new CopyOnWriteArrayList<>();

// 3. BlockingQueue实现类
BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();

特点：

比使用同步包装器（如Collections.synchronizedList）性能更好
提供特殊的并发特性（如BlockingQueue的put/take操作）

八、volatile关键字

原理：保证变量的可见性和有序性（但不保证原子性）

实现方式：

public class VolatileExample {
    private volatile boolean flag;
    
    public void toggle() {
        flag = !flag;  // 注意：这不是原子操作！
    }
}

适用场景：

状态标志（如关闭标志）
单次安全发布（如双重检查锁定模式）

九、消息传递（Message Passing）

原理：通过线程间通信而非共享内存实现安全

实现方式：

// 使用BlockingQueue实现生产者-消费者模式
BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

// 生产者
new Thread(() -> {
    queue.put("message");
}).start();

// 消费者
new Thread(() -> {
    String msg = queue.take();
    // 处理消息
}).start();

十、不可变数据结构（Immutable Data Structures）

原理：每次修改返回新对象而非修改原对象

实现方式：

// 使用Guava的不可变集合
ImmutableList<String> list = ImmutableList.of("a", "b", "c");
ImmutableList<String> newList = ImmutableList.<String>builder()
    .addAll(list)
    .add("d")
    .build();