本文共 4180 字，大约阅读时间需要 13 分钟。

线程安全编程指南

1. 线程安全的基础

线程安全是Java并发编程中的核心问题之一。在多线程环境下，共享资源的访问必须是安全的，避免数据竞争和脏读等问题。Java提供了两种关键工具来实现线程安全：volatile和synchronized。此外，Atomic系列（如AtomicInteger、AtomicLong等）提供了更高级别的原子操作，解决了volatile的局限性。

2. volatile的适用条件

volatile关键字用于确保共享变量在所有线程中具有一致性，但其使用必须满足以下条件：

• 不依赖于当前值：只有当单个线程修改共享变量时，其他线程才能依赖其当前值。
• 不在其他不变式中：变量不能作为其他不变式的一部分。

volatile的常见错误使用场景是像i++这样依赖于当前值的操作。多个线程同时读取并修改同一个计数器会导致丢失更新。例如，两个线程同时读取计数器的值8，并各自加一，结果会变成10，而不是预期的10次更新。

3. 原子变量的引入

为了修复volatile的局限性，Java从1.5开始引入了原子变量和原子引用。AtomicBoolean、AtomicInteger、AtomicLong和AtomicReference等类提供了原子操作，它们不仅具有volatile的可见性，还允许修改操作依赖于当前值，避免了volatile的竞争问题。

4. 编写线程安全类

以下是一个简单的线程安全类示例：

package com.boonya.thread;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class StateSafeThread extends Thread {
    private static final AtomicInteger atomicCount = new AtomicInteger(0);
    private static final AtomicInteger volatileAtomicCount = new AtomicInteger(0);
    @Override
    public void run() {
        final Object lock = new Object();
        for (int i = 0; i < 50000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (lock) {
                        // 不进行任何操作
                    }
                    atomicCount.incrementAndGet();
                    volatileAtomicCount.incrementAndGet();
                }
            }).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread Name: " + this.getName());
        System.out.println("线程并发执行对计数器累计5000次，请查看并发结果！");
        System.out.println("atomicCount=" + atomicCount.get());
        System.out.println("volatileAtomicCount=" + volatileAtomicCount.get());
    }
}

5. 线程池测试

以下是一个线程池测试类示例：

package com.boonya.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
public class StateSafeThreadTest {
    @Test
    public void testByOneThread() {
        for (int i = 0; i < 5; i++) {
            StateSafeThread thread = new StateSafeThread();
            thread.start();
        }
        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void testByThreadPool() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            StateSafeThread thread = new StateSafeThread();
            executorService.execute(thread);
        }
        try {
            executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
    @Test
    public void testByThreadPool2() {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            StateSafeThread thread = new StateSafeThread();
            executorService.execute(thread);
        }
        try {
            executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
    @Test
    public void testByThreadPool3() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            StateSafeThread thread = new StateSafeThread();
            executorService.execute(thread);
        }
        try {
            executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

6. 测试结果分析

通过测试可以发现：

• 使用线程池时，线程安全类的行为取决于线程池的设置：
  • 如果线程池的线程数大于或等于线程的数量（如newFixedThreadPool(5)），则线程安全。
  • 如果线程池的线程数小于线程的数量（如newFixedThreadPool(3)），则线程不安全。
  • newCachedThreadPool()默认创建新线程以应对高负载，同样需要线程安全类来确保正确性。

通过合理选择线程池类型，可以确保线程安全类的正确运行。推荐使用缓存线程池以优化性能和资源利用率。

转载地址：http://jeyu.baihongyu.com/