Java 线程安全保障机制：除 volatile 外的核心方案

// 保护实例变量的同步方法
class SafeCounter {
    privateint count = 0;
    
    public synchronized void increment() {
        count++; // 临界区：原子执行
    }
    
    public synchronized int getCount() {
        return count;
    }
}

// 同步代码块（减小锁粒度）
class SafeService {
    privatefinal Object lock = new Object();
    
    public void doSomething() {
        // 仅锁定核心临界区，而非整个方法
        synchronized (lock) {
            // 核心操作
        }
        // 非临界区代码（无需锁定）
    }
}

import java.util.concurrent.locks.ReentrantLock;

class SafeCounter {
    privateint count = 0;
    privatefinal ReentrantLock lock = new ReentrantLock(); // 默认非公平锁
    
    public void increment() {
        lock.lock(); // 手动加锁
        try {
            count++; // 临界区
        } finally {
            lock.unlock(); // 必须在 finally 中释放锁，避免异常导致锁泄漏
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

// 公平锁 + 条件变量示例
class ConditionDemo {
    privatefinal ReentrantLock lock = new ReentrantLock(true); // 公平锁
    privatefinal Condition notEmpty = lock.newCondition();
    privatefinal Condition notFull = lock.newCondition();
    privatefinal String[] queue = new String[10];
    privateint size = 0;
    
    public void put(String item) throws InterruptedException {
        lock.lock();
        try {
            while (size == queue.length) {
                notFull.await(); // 队列满，等待
            }
            queue[size++] = item;
            notEmpty.signal(); // 唤醒等待取数据的线程
        } finally {
            lock.unlock();
        }
    }
    
    public String take() throws InterruptedException {
        lock.lock();
        try {
            while (size == 0) {
                notEmpty.await(); // 队列空，等待
            }
            String item = queue[0];
            System.arraycopy(queue, 1, queue, 0, --size);
            notFull.signal(); // 唤醒等待放数据的线程
            return item;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

// 原子类实现线程安全计数
class AtomicCounter {
    privatefinal AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet(); // 原子自增（等价于 count++）
    }
    
    // 复杂原子操作：CAS 重试
    public void incrementIfLessThan100() {
        while (true) {
            int current = count.get();
            if (current >= 100) {
                break;
            }
            // CAS 替换：预期值为 current，更新为 current+1
            if (count.compareAndSet(current, current + 1)) {
                break;
            }
        }
    }
    
    public int getCount() {
        return count.get();
    }
}

// LongAdder 高并发累加（优于 AtomicLong）
import java.util.concurrent.atomic.LongAdder;

class HighConcurrencyCounter {
    privatefinal LongAdder adder = new LongAdder();
    
    public void add() {
        adder.increment();
    }
    
    public long getTotal() {
        return adder.sum();
    }
}

public final class String {
    private final char value[]; // 不可变的字符数组
    private final int hash; // 缓存哈希值
    
    // 无 setter 方法，所有修改操作（如 substring、replace）都返回新对象
    public String substring(int beginIndex) {
        // 省略实现：返回新的 String 对象
    }
}

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

// 不可变的用户信息类
publicfinalclass ImmutableUser {
    privatefinal String id;
    privatefinal String name;
    privatefinal List<String> roles; // 可变集合，需特殊处理
    
    // 构造方法初始化所有字段
    public ImmutableUser(String id, String name, List<String> roles) {
        this.id = id;
        this.name = name;
        // 拷贝传入的集合，避免外部修改
        this.roles = Collections.unmodifiableList(new ArrayList<>(roles));
    }
    
    // 仅提供 getter 方法，无 setter
    public String getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
    // 返回不可变视图，避免外部修改集合
    public List<String> getRoles() {
        return roles;
    }
}

// 局部变量仅在当前线程栈中，天然线程安全
public int calculate() {
    int sum = 0; // 栈封闭变量
    for (int i = 0; i < 100; i++) {
        sum += i;
    }
    return sum;
}

import java.text.SimpleDateFormat;

// ThreadLocal 解决 SimpleDateFormat 线程不安全问题
class DateUtil {
    // 每个线程拥有独立的 SimpleDateFormat 副本
    privatestaticfinal ThreadLocal<SimpleDateFormat> sdf = ThreadLocal.withInitial(
        () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    );
    
    public static String format(long timestamp) {
        return sdf.get().format(timestamp);
    }
    
    // 线程退出前清理，避免内存泄漏
    public static void remove() {
        sdf.remove();
    }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// ConcurrentHashMap 高并发读写
class ConcurrentMapDemo {
    privatefinal Map<String, Integer> map = new ConcurrentHashMap<>();
    
    public void put(String key, int value) {
        map.put(key, value); // 原子操作，无需额外同步
    }
    
    public Integer get(String key) {
        return map.get(key);
    }
    
    // 原子性的复合操作
    public void increment(String key) {
        map.compute(key, (k, v) -> v == null ? 1 : v + 1);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class ThreadPoolDemo {
    // 创建固定大小的线程池
    privatefinal ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public void submitTask(Runnable task) {
        executor.submit(task);
    }
    
    // 优雅关闭线程池
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
}