java并发编程线程介绍-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_38041439/article/details/146346349

Java并发编程实战：synchronized、volatile与线程通信深度解析

引言：现代Java并发的核心挑战

在多核处理器成为标配的今天，Java并发编程能力已成为开发者核心竞争力的重要组成部分。根据Oracle官方统计，超过60%的生产环境故障与线程安全问题直接相关。本文将围绕三大核心要素（synchronized、volatile、线程通信），结合JDK17最新特性，深入剖析并发编程的本质原理与实践技巧。

一、并发编程三大基石解析

1.1 线程安全本质探秘

在这里插入图片描述

JMM内存模型：主内存与工作内存的分离设计
三大核心问题：

问题复现场景：

// 典型竞态条件示例
class Counter {
    private int count = 0;
    
    public void add() {
        for (int i=0; i<10000; i++) {
            count++;  // 非原子操作
        }
    }
}

1.2 synchronized深度剖析

1.2.1 实现原理

Monitor机制：每个对象关联的监视器锁
锁升级过程：

1.2.2 高级特性

// 锁消除示例
public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();  // JIT编译器会消除同步操作
}

1.3 volatile的内存语义

1.3.1 内存屏障实现

// 写操作语义
storeStoreBarrier();
// 写volatile变量
storeLoadBarrier();

// 读操作语义
loadLoadBarrier();
// 读volatile变量
loadStoreBarrier();

1.3.2 典型应用场景

// 状态标志位
class TaskRunner {
    private volatile boolean running = true;
    
    public void stop() { running = false; }
    
    public void run() {
        while (running) {
            // 执行任务
        }
    }
}

二、高级同步模式实战

2.1 双重检查锁演进史

// 正确实现（JDK5+）
public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {                     // 第一次检查
            synchronized (Singleton.class) {        // 类级别锁
                if (instance == null) {             // 第二次检查
                    instance = new Singleton();     // volatile禁止指令重排
                }
            }
        }
        return instance;
    }
}

指令重排问题解析：

2.2 生产者-消费者模型优化版

// 使用BlockingQueue实现
public class AdvancedProducerConsumer {
    private final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);
    private volatile boolean isStopped = false;
    private final ExecutorService exec = Executors.newCachedThreadPool();

    class Producer implements Runnable {
        public void run() {
            try {
                int i = 0;
                while (!Thread.interrupted() && !isStopped) {
                    queue.put(i);  // 自动阻塞
                    System.out.println("Produced: " + i++);
                    TimeUnit.MILLISECONDS.sleep(100);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    class Consumer implements Runnable {
        public void run() {
            try {
                while (!Thread.interrupted() && (!isStopped || !queue.isEmpty())) {
                    Integer value = queue.take();  // 自动阻塞
                    System.out.println("Consumed: " + value);
                    TimeUnit.MILLISECONDS.sleep(150);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public void start() {
        exec.execute(new Producer());
        exec.execute(new Consumer());
        
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            isStopped = true;
            exec.shutdownNow();
            System.out.println("System exited safely");
        }));
    }
}

三、Java并发体系全景图

3.1 并发工具类选型指南

场景	推荐工具类	特性说明
状态同步	CountDownLatch	一次性栅栏
循环屏障	CyclicBarrier	可重复使用
资源池管理	Semaphore	流量控制
数据交换	Exchanger	双线程数据交换
延迟队列	DelayQueue	时间排序队列

3.2 线程池配置黄金法则

四、性能调优与陷阱规避

4.1 锁优化七大原则

减小锁粒度：使用ConcurrentHashMap的分段锁
降低锁持有时间：同步块内避免耗时操作
读写分离：ReadWriteLock的应用
无锁编程：AtomicStampedReference等原子类
避免嵌套锁：预防死锁发生
锁排序：统一获取锁的顺序
定时锁：tryLock()设置超时时间

4.2 常见陷阱案例

// 错误示例：误用String作为锁
class DangerousLock {
    private final String lock = "LOCK";
    
    public void doSomething() {
        synchronized(lock) {  // 字符串常量池问题
            // ...
        }
    }
}

// 正确做法
class SafeLock {
    private final Object lock = new Object();
    
    public void doSomething() {
        synchronized(lock) {
            // ...
        }
    }
}

五、未来趋势：虚拟线程（协程）

5.1 Loom项目核心特性

// 虚拟线程使用示例（JDK19+）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}