1. 线程安全与可见性基础概念在Java并发编程中线程安全和可见性是两个最核心也最容易出问题的概念。我见过太多项目因为对这两个概念理解不到位导致线上出现难以复现的诡异bug。先明确下定义线程安全指的是当多个线程访问某个共享资源时无论运行时环境采用何种调度方式代码都能表现出正确的行为。而可见性则是指一个线程对共享变量的修改能够及时被其他线程看到。这两个概念看似简单但在实际开发中却暗藏玄机。比如下面这个经典案例public class VisibilityDemo { private static boolean flag true; public static void main(String[] args) throws InterruptedException { new Thread(() - { while (flag) { // 空循环 } System.out.println(Thread stopped); }).start(); Thread.sleep(1000); flag false; System.out.println(Main thread set flag to false); } }你猜这个程序会正常退出吗实际运行会发现子线程可能永远无法退出这就是典型的可见性问题 - 主线程对flag的修改对子线程不可见。2. 内存模型与happens-before原则要理解线程安全和可见性必须深入Java内存模型(JMM)。JMM定义了线程如何以及何时可以看到其他线程写入的共享变量以及如何同步对这些变量的访问。关键点在于happens-before原则它规定了哪些操作必须发生在哪些操作之前。几个重要的happens-before规则程序顺序规则同一线程中的每个操作happens-before于该线程中的任意后续操作监视器锁规则对一个锁的解锁happens-before于随后对这个锁的加锁volatile变量规则对volatile域的写happens-before于任意后续对这个volatile域的读传递性如果A happens-before B且B happens-before C那么A happens-before C理解这些规则对编写正确的并发代码至关重要。比如我们来看一个双重检查锁定(DCL)的实现public class Singleton { private static Singleton instance; public static Singleton getInstance() { if (instance null) { synchronized (Singleton.class) { if (instance null) { instance new Singleton(); } } } return instance; } }这个看似完美的实现其实是有问题的因为new Singleton()操作和将引用赋值给instance之间可能存在重排序导致其他线程看到未完全初始化的对象。正确的做法是将instance声明为volatile。3. 保证线程安全的几种方式在实际项目中我们有多种方式可以保证线程安全各有适用场景3.1 不可变对象最简单的线程安全方案就是使用不可变对象。如果一个对象创建后其状态不能被修改那么它天生就是线程安全的。Java中的String、Integer等都是不可变对象的典型例子。创建不可变对象需要遵循几个原则所有字段设为final类本身声明为final防止子类修改不提供修改内部状态的方法如果字段是可变对象的引用需要防御性拷贝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; } }3.2 同步代码块使用synchronized关键字是最直接的线程安全方案。它可以确保同一时刻只有一个线程能执行特定代码块或方法。public class Counter { private int count; public synchronized void increment() { count; } public synchronized int getCount() { return count; } }但同步会带来性能开销过度使用会导致程序吞吐量下降。我建议只在必要时使用同步并且尽量减小同步块的范围。3.3 volatile关键字volatile比synchronized更轻量它能保证变量的可见性但不保证原子性。适合用于状态标志等简单场景public class TaskRunner { private volatile boolean running true; public void stop() { running false; } public void run() { while (running) { // 执行任务 } } }注意volatile不能用于需要原子性操作的场景比如i这种复合操作。3.4 原子类Java并发包提供了一系列原子类(AtomicInteger等)它们利用CAS(Compare-And-Swap)指令实现了无锁线程安全public class AtomicCounter { private AtomicInteger count new AtomicInteger(0); public void increment() { count.incrementAndGet(); } public int getCount() { return count.get(); } }原子类在高并发场景下性能通常优于同步方案因为它们避免了线程阻塞。3.5 并发容器Java集合框架提供了线程安全的并发容器实现如ConcurrentHashMap、CopyOnWriteArrayList等。这些容器内部已经处理好了线程安全问题可以直接在多线程环境中使用。public class Cache { private ConcurrentMapString, Object store new ConcurrentHashMap(); public void put(String key, Object value) { store.put(key, value); } public Object get(String key) { return store.get(key); } }4. 实战案例分析让我们通过一个电商系统中的库存扣减案例看看如何选择合适的线程安全方案。4.1 问题描述电商系统中多个用户可能同时购买同一商品需要确保库存不会超卖扣减操作高效系统可扩展4.2 方案选型方案一数据库悲观锁public boolean deductStock(Long productId, int quantity) { // SELECT ... FOR UPDATE // 检查库存 // 扣减库存 // UPDATE ... }优点实现简单 缺点性能差扩展性低方案二应用层同步public synchronized boolean deductStock(Long productId, int quantity) { // 检查库存 // 扣减库存 }优点实现简单 缺点性能差成为系统瓶颈方案三乐观锁重试public boolean deductStock(Long productId, int quantity) { int retry 3; while (retry-- 0) { Product product getProduct(productId); if (product.getStock() quantity) { return false; } int oldVersion product.getVersion(); if (updateStock(productId, quantity, oldVersion) 0) { return true; } } return false; }优点性能好 缺点实现复杂方案四Redis原子操作public boolean deductStock(Long productId, int quantity) { String script if redis.call(get, KEYS[1]) ARGV[1] then return redis.call(decrby, KEYS[1], ARGV[1]) else return -1 end; Long result redisTemplate.execute( new DefaultRedisScript(script, Long.class), Collections.singletonList(stock: productId), String.valueOf(quantity)); return result ! null result 0; }优点性能极佳 缺点需要维护缓存一致性4.3 性能对比在100并发下测试结果方案QPS平均响应时间备注悲观锁120830ms数据库成瓶颈同步块851170ms单节点性能差乐观锁210047ms需要重试机制Redis450022ms最佳性能4.4 最终选择根据业务场景选择中小型系统乐观锁方案大型高并发系统Redis方案异步同步数据库超高并发分布式锁Redis方案5. 常见问题与排查技巧5.1 死锁问题死锁是并发编程中最棘手的问题之一。典型症状是程序卡死CPU使用率低。排查步骤使用jstack获取线程dump查找BLOCKED状态的线程分析锁的持有和等待关系预防死锁的建议按固定顺序获取锁使用tryLock设置超时避免在持有锁时调用外部方法5.2 竞态条件竞态条件通常表现为偶尔出现的错误难以复现。典型例子是检查再行动(check-then-act)模式if (!map.containsKey(key)) { map.put(key, value); }解决方案使用线程安全容器使用原子操作使用同步块5.3 内存一致性错误这类错误表现为线程看到的数据不一致。常见原因未正确使用volatile未遵循happens-before原则发布未完全构造的对象排查工具Java内存模型验证工具静态分析工具FindBugs5.4 性能问题过度同步会导致性能下降。优化建议减小同步范围使用读写锁替代独占锁考虑无锁数据结构使用并发容器性能分析工具JProfilerVisualVMJava Mission Control6. 高级主题与最佳实践6.1 线程封闭避免同步的一种有效方式是不共享数据。线程封闭技术包括栈封闭局部变量ThreadLocal线程特有变量对象封闭特定线程独占对象public class RequestProcessor { private static ThreadLocalSimpleDateFormat dateFormat ThreadLocal.withInitial(() - new SimpleDateFormat(yyyy-MM-dd)); public void process(Request request) { // 每个线程有自己的dateFormat实例 String date dateFormat.get().format(new Date()); // ... } }6.2 不变性与函数式编程函数式编程强调不可变性这天然适合并发环境。Java 8引入的流式API和lambda表达式使得编写并发代码更加容易public ListProduct getHotProducts(ListLong productIds) { return productIds.parallelStream() .map(this::getProductInfo) .filter(p - p.getSales() 1000) .sorted(comparing(Product::getSales).reversed()) .collect(Collectors.toList()); }6.3 并发设计模式一些有用的并发设计模式生产者-消费者模式BlockingQueue实现工作窃取模式ForkJoinPool实现领导者-追随者模式处理高并发IO// 生产者-消费者示例 public class LogProcessor { private final BlockingQueueLogEntry queue new LinkedBlockingQueue(); public void start() { // 生产者线程 new Thread(() - { while (true) { LogEntry entry getNextLogEntry(); queue.put(entry); } }).start(); // 消费者线程 for (int i 0; i 4; i) { new Thread(() - { while (true) { LogEntry entry queue.take(); processLogEntry(entry); } }).start(); } } }6.4 性能优化技巧避免锁的粗化不要将不相关的操作放在同一个同步块中减小锁粒度如ConcurrentHashMap的分段锁读写分离使用ReadWriteLock无锁算法如CAS操作避免热点如AtomicLong在高并发下的性能问题可以使用LongAdder// 使用LongAdder替代AtomicLong public class ClickCounter { private final LongAdder count new LongAdder(); public void click() { count.increment(); } public long getCount() { return count.sum(); } }7. 工具与框架推荐7.1 监控工具JConsole基本JVM监控VisualVM功能更强大的分析工具Java Mission Control商业级监控Arthas阿里开源的Java诊断工具7.2 测试工具JMHJava微基准测试工具JUnit单元测试框架TestNG更强大的测试框架Mockito模拟对象框架7.3 并发框架Fork/Join框架适合计算密集型任务Executor框架线程池管理CompletableFuture异步编程RxJava响应式编程// CompletableFuture示例 public CompletableFutureString getUserInfoAsync(String userId) { return CompletableFuture.supplyAsync(() - getUserBasicInfo(userId)) .thenCombine(getUserCreditAsync(userId), (basic, credit) - basic , Credit: credit); }8. 实际项目经验分享在多年的Java并发编程实践中我总结了以下几点经验优先考虑无共享架构能用线程封闭解决的问题就不要用同步尽量使用高层抽象如并发容器、Executor框架等而不是自己实现避免过早优化先保证正确性再考虑性能充分测试并发场景包括压力测试和长时间运行测试记录并发控制决策在代码注释中说明为什么选择特定的并发控制方式一个典型的错误案例曾经在项目中使用了双重检查锁定来实现单例但没有使用volatile导致在特定硬件环境下出现难以复现的问题。后来通过以下方式修复public class SafeSingleton { private static volatile SafeSingleton instance; public static SafeSingleton getInstance() { if (instance null) { synchronized (SafeSingleton.class) { if (instance null) { instance new SafeSingleton(); } } } return instance; } }另一个经验是关于锁粒度的选择。在一个高并发的交易系统中最初我们使用了一个全局锁来保护所有交易操作导致性能瓶颈。后来改为按用户ID哈希分组锁性能提升了8倍public class TradeService { private final Object[] locks new Object[16]; { for (int i 0; i locks.length; i) { locks[i] new Object(); } } public void trade(long userId, TradeAction action) { int lockIndex (int) (userId % locks.length); synchronized (locks[lockIndex]) { // 执行交易操作 } } }最后关于可见性问题的一个实际案例在分布式配置中心项目中配置变更后需要立即对所有线程可见。最初我们使用了普通的变量加同步块后来发现某些情况下配置更新会有延迟。最终解决方案是使用volatile结合CopyOnWriteArrayListpublic class ConfigCenter { private volatile Config currentConfig; private final CopyOnWriteArrayListConfigListener listeners new CopyOnWriteArrayList(); public void updateConfig(Config newConfig) { this.currentConfig newConfig; for (ConfigListener listener : listeners) { listener.onConfigChanged(newConfig); } } public Config getCurrentConfig() { return currentConfig; } }