java多线程和并发pdf

备案号:蜀ICP备2026035467号-3 | 网址:www.xservx.com

⚡ java多线程和并发pdf:高并发系统设计基石

在现代分布式系统架构中,java多线程和并发能力已成为后端开发者的核心竞争力。本页面系统整理了从基础概念到高级实践的完整知识体系,涵盖线程生命周期、线程安全机制、锁优化策略、并发工具类应用、JMM内存模型及实战项目设计,所有内容均以PDF形式提供免费下载,并辅以详实代码示例与高频面试题解析。

根据2024年技术社区调研数据,java多线程相关问题在Java开发者技术面试中出现频率高达92%,而能准确阐述volatile语义与happens-before规则的候选人不足35%。本资料特别针对以下高频痛点展开深度剖析:线程间通信的正确姿势、死锁检测与预防、无锁编程技巧、线程池参数调优、高并发下ThreadLocal内存泄漏规避等。

资料结构遵循“认知-实践-提升”三阶模型:第一阶段夯实理论基础(线程状态转换、同步原语语义),第二阶段通过典型场景(秒杀系统、订单超时处理)理解并发模型选择,第三阶段深入JVM层面分析线程调度机制与GC对并发性能的影响。所有示例均通过JDK 17验证,兼容主流框架如Spring Boot、Netty、Dubbo的并发配置实践。

特别说明:本资料不依赖第三方插件,所有代码片段可直接复制运行。建议结合《Java并发编程实战》(Brian Goetz著)同步阅读,重点理解“共享与可见性”、“原子性保证”、“线程封闭”三大核心原则在实际工程中的落地方式。

⚙️ 并发编程三大核心原则深度解析

⑴ 原子性:不可分割的操作单元

在java多线程中,原子性指操作一旦开始便不可被中断的特性。JVM层面通过CAS(Compare-And-Swap)指令实现原子操作,典型代表是java.util.concurrent.atomic包下的AtomicInteger、LongAdder等类。

典型误区:i++看似单行代码,实际包含读取→自增→写入三步操作,非原子性操作。在高并发场景下,1000次自增可能仅得到900+结果。正确做法:使用AtomicInteger.incrementAndGet()。

代码示例:

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicDemo {
    private static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    count.incrementAndGet(); // 原子自增
                }
            });
            threads[i].start();
        }
        for (Thread t : threads) t.join();
        System.out.println("最终结果:" + count.get()); // 10000
    }
}

⑵ 可见性:线程间状态同步保障

Java内存模型(JMM)规定:线程工作内存与主内存间的数据同步需通过特定指令触发。若无可见性保障,一个线程修改共享变量后,其他线程可能读取到旧值。

volatile关键字作用:保证变量修改后立即写回主内存,且新值对其他线程立即可见。但需注意:volatile不保证原子性(如volatile int i = 0; i++仍非原子)。

典型场景:线程间通信标志位设计。以下代码中,flag变量未加volatile可能导致子线程无法退出:

public class VisibilityDemo {
    private static volatile boolean flag = true; // 必须加volatile
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag) {
                // 执行业务逻辑
            }
            System.out.println("线程已退出");
        }).start();
        Thread.sleep(1000);
        flag = false; // 主线程修改标志位
    }
}

⑶ 有序性:指令重排序的约束机制

编译器与CPU为优化性能可能对指令重排序,但JMM通过happens-before规则确保关键操作的执行顺序。在java多线程和并发中,需特别关注以下场景:

  • 程序顺序规则:单线程内代码按顺序执行
  • volatile规则:对volatile变量的写先行发生于后续读
  • 锁规则:解锁先行发生于后续加锁
  • 线程启动规则:start()调用先行发生于线程执行

DCL单例模式修正:双重检查锁定需配合volatile防止指令重排序导致的半初始化对象问题:

public class Singleton {
    private static volatile Singleton instance; // 关键:volatile防止重排序
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 非原子操作:分配内存→初始化→引用赋值
                }
            }
        }
        return instance;
    }
}

〔线程管理〕从创建到销毁的完整生命周期

线程六种状态详解

java.lang.Thread.State定义了NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED六种状态,实际运行中状态转换如下:

状态触发条件典型场景
NEW线程对象创建后未调用start()Thread t = new Thread()
RUNNABLE调用start()后进入就绪队列线程竞争CPU时间片
BLOCKED等待进入synchronized同步块多个线程竞争锁资源
WAITING调用wait()/join()无参方法生产者-消费者模型
TIMED_WAITING调用sleep()/wait(timeout)定时任务调度
TERMINATEDrun()方法执行完毕线程自然结束

三种线程创建方式对比

  1. 继承Thread类:简单但受限于单继承,不推荐
  2. 实现Runnable接口:避免单继承局限,推荐用于简单任务
  3. 实现Callable接口+Future:支持返回值与异常处理,配合ThreadPoolExecutor使用

Callable示例:

import java.util.concurrent.*;
public class CallableDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Future future = pool.submit(() -> {
            return 100 + 200; // 返回计算结果
        });
        System.out.println("结果:" + future.get()); // 阻塞等待结果
        pool.shutdown();
    }
}

线程协作:join与yield机制

join()方法使当前线程等待目标线程执行完毕。常见用途:主线程需等待子线程完成初始化后继续执行。

典型问题:join()内部通过wait()实现,需注意线程中断时的异常处理:

public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            System.out.println("子线程开始执行");
            try { Thread.sleep(2000); } catch (InterruptedException e) {}
            System.out.println("子线程执行完毕");
        });
        worker.start();
        worker.join(); // 主线程等待
        System.out.println("主线程继续执行");
    }
}

🔒 锁机制:从synchronized到ReentrantLock

⑴ synchronized深度剖析

锁升级路径:无锁→偏向锁→轻量级锁→重量级锁。JDK 6起引入偏向锁机制,对单线程加锁场景大幅优化。

锁消除与锁粗化:

  • 锁消除:JIT编译器检测到同步块无竞争时自动移除(如StringBuffer.append())
  • 锁粗化:将多次连续加锁合并为一次(如循环内同步块)

典型陷阱:字符串常量池共享导致意外锁竞争。以下代码中,所有线程竞争同一把锁:

public class StringLockDemo {
    private static final String LOCK = "lock";
    public void process() {
        synchronized(LOCK) { // 锁对象为常量池共享对象
            // 执行关键操作
        }
    }
}

⑵ ReentrantLock高级特性

相比synchronized,ReentrantLock提供:

  • 可中断锁获取(lockInterruptibly())
  • 超时锁获取(tryLock(timeout, unit))
  • 公平锁支持(构造函数传入true)
  • 条件变量(Condition)实现精准唤醒

条件变量应用:生产者-消费者模型中避免忙等:

public class ProducerConsumer {
    private final Queue queue = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    public void produce() throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == 10) notFull.await();
            queue.offer(1);
            notEmpty.signal();
        } finally { lock.unlock(); }
    }
    public void consume() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) notEmpty.await();
            queue.poll();
            notFull.signal();
        } finally { lock.unlock(); }
    }
}

⑶ 读写锁与StampedLock

ReadWriteLock适用于读多写少场景,允许多个读线程并发访问:

public class CacheDemo {
    private final Map cache = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    public Object get(String key) {
        rwLock.readLock().lock();
        try { return cache.get(key); }
        finally { rwLock.readLock().unlock(); }
    }
    public void put(String key, Object value) {
        rwLock.writeLock().lock();
        try { cache.put(key, value); }
        finally { rwLock.writeLock().unlock(); }
    }
}

StampedLock提供三种模式:写锁、悲观读锁、乐观读锁。乐观读锁不阻塞写线程,适用于高并发读场景:

public class OptimisticReadDemo {
    private final StampedLock lock = new StampedLock();
    public double readData() {
        long stamp = lock.tryOptimisticRead(); // 乐观读
        double value = readValue(); // 非阻塞读取
        if (!lock.validate(stamp)) { // 检查是否有写操作
            stamp = lock.readLock(); // 升级为悲观读锁
            try { value = readValue(); }
            finally { lock.unlockRead(stamp); }
        }
        return value;
    }
}

〔并发工具类〕JUC包实战应用指南

线程池参数调优实战

ThreadPoolExecutor核心参数:

参数作用推荐值
corePoolSize核心线程数CPU核心数+1(IO密集型:2×CPU)
maximumPoolSize最大线程数根据队列容量动态调整
keepAliveTime空闲线程存活时间30秒(非核心线程)
workQueue任务队列ArrayBlockingQueue(有界队列)

拒绝策略选择:

  • AbortPolicy:抛出异常(默认)
  • CallerRunsPolicy:调用者线程执行(避免丢任务)
  • DiscardOldestPolicy:丢弃最老任务

自定义线程池示例:

public class ThreadPoolFactory {
    public static ExecutorService createCustomPool() {
        return new ThreadPoolExecutor(
            4, // corePoolSize
            8, // maximumPoolSize
            30, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100),
            new ThreadFactoryBuilder().setNameFormat("worker-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

CountDownLatch倒计时器

适用于等待多个异步任务全部完成的场景。典型用法:主线程等待所有初始化任务完成后再启动服务。

public class CountdownDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try { Thread.sleep(1000); }
                catch (InterruptedException e) {}
                System.out.println("任务完成");
                latch.countDown();
            }).start();
        }
        latch.await(); // 等待所有任务完成
        System.out.println("所有任务完成,继续执行");
    }
}

CyclicBarrier循环屏障

适用于多线程分阶段协作计算。与CountDownLatch区别:CyclicBarrier可重用,且所有线程到达屏障点后可执行统一动作。

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程到达屏障点,执行汇总");
        });
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    Thread.sleep((long)(Math.random()*2000));
                    System.out.println(Thread.currentThread().getName() + "到达");
                    barrier.await();
                } catch (Exception e) { e.printStackTrace(); }
            }).start();
        }
    }
}

📜 Java内存模型(JMM)核心规则

⑴ happens-before原则详解

JMM通过happens-before规则定义操作间的可见性关系,关键规则包括:

  • 程序顺序规则:单线程内按代码顺序
  • 监视器锁规则:unlock()先行发生于后续lock()
  • volatile变量规则:写先行发生于后续读
  • 线程启动规则:start()先行发生于run()
  • 线程终止规则:线程内操作先行发生于join()返回
  • 中断规则:interrupt()先行发生于检测中断
  • 对象终结规则:构造完成先行发生于finalize()

典型反例:未使用volatile的双重检查锁定可能返回半初始化对象:

// 错误写法(缺少volatile)
class Singleton {
    private static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null)
                    instance = new Singleton(); // 可能重排序!
            }
        }
        return instance;
    }
}

⑵ 内存屏障与CPU缓存一致性

为实现happens-before规则,JMM引入四种内存屏障:

  1. StoreStore屏障:禁止屏障前写操作与屏障后写操作重排序
  2. StoreLoad屏障:防止写操作与后续读操作重排序(最重)
  3. LoadLoad屏障:禁止屏障前读操作与屏障后读操作重排序
  4. LoadStore屏障:禁止屏障前读操作与屏障后写操作重排序

volatile写插入屏障:在volatile写操作后插入StoreStore屏障+StoreLoad屏障

volatile读插入屏障:在volatile读操作前插入LoadLoad屏障+LoadStore屏障

⑶ 伪共享与缓存行填充

CPU缓存以缓存行(通常64字节)为单位加载。当多个线程修改同一缓存行内的不同变量时,即使变量无关联,也会因缓存行 invalidate 导致性能下降(伪共享)。

解决方案:使用@Contended注解(JDK 8+)或手动填充字段:

@sun.misc.Contended
public static class Counter {
    public volatile long value;
}
// 手动填充(兼容JDK 7)
public static class PaddedCounter {
    public volatile long value;
    // 填充至64字节缓存行
    public long p1, p2, p3, p4, p5, p6, p7;
}

〔高并发实战〕典型场景解决方案

⑴ 秒杀系统限流设计

方案对比:

方案优点缺点适用场景
令牌桶平滑限流需维护桶容量高并发写请求
漏桶恒定输出速率突发流量易丢弃稳定吞吐场景
计数器实现简单时间窗口边界突变低频请求

令牌桶实现:

public class TokenBucketLimiter {
    private final long capacity; // 桶容量
    private final long refillRate; // 补充速率
    private long tokens; // 当前令牌数
    private long lastRefillTime;
    public synchronized boolean tryAcquire() {
        refill();
        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false;
    }
    private void refill() {
        long now = System.nanoTime();
        long tokensToAdd = (now - lastRefillTime) * refillRate / 1_000_000_000;
        tokens = Math.min(capacity, tokens + tokensToAdd);
        lastRefillTime = now;
    }
}

⑵ 分布式ID生成器

Snowflake算法优化:

  • 时钟回拨处理:检测时间戳回退时等待或抛异常
  • 工作机器ID分配:使用Zookeeper/ZooKeeper分配唯一ID
  • 序列号溢出处理:等待至下一毫秒

简化版实现:

public class SnowflakeIdGenerator {
    private final long workerIdBits = 10;
    private final long sequenceBits = 12;
    private final long maxWorkerId = (1L << workerIdBits) - 1;
    private final long maxSequence = (1L << sequenceBits) - 1;
    private long lastTimestamp = -1L;
    private long workerId;
    private long sequence = 0L;
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        if (timestamp < lastTimestamp) throw new RuntimeException("时钟回拨");
        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & maxSequence;
            if (sequence == 0) timestamp = tilNextMillis(lastTimestamp);
        } else {
            sequence = 0;
        }
        lastTimestamp = timestamp;
        return (timestamp << 22) | (workerId << 12) | sequence;
    }
    private long tilNextMillis(long lastTimestamp) {
        long timestamp;
        while ((timestamp = System.currentTimeMillis()) <= lastTimestamp);
        return timestamp;
    }
}

⑶ 限流熔断机制

Hystrix替代方案(Spring Cloud 2020+):

  • Resilience4J:轻量级断路器实现
  • Sentinel:阿里开源流量治理组件

Resilience4J断路器配置:

CircuitBreakerConfig config = CircuitBreakerConfig.custom()
    .failureRateThreshold(50) // 失败率阈值
    .waitDurationInOpenState(Duration.ofSeconds(60)) // 半开等待时间
    .slidingWindowSize(10) // 滑动窗口大小
    .build();

〔网友常见问题〕高频技术问题深度解答

Q1:线程池中线程异常后如何恢复?

问题现象:线程池中任务抛出未捕获异常后,线程直接终止,导致线程池容量减少。

解决方案:

  1. 实现ThreadFactory包装线程,添加uncaughtExceptionHandler
  2. 使用ExecutorService.submit()包装任务,通过Future.get()捕获异常
  3. 自定义ThreadPoolExecutor重写afterExecute方法

推荐方案(重写afterExecute):

public class ExceptionHandlingExecutor extends ThreadPoolExecutor {
    public ExceptionHandlingExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof Future) {
            try {
                ((Future) r).get();
            } catch (CancellationException ce) { t = ce; }
            catch (ExecutionException ee) { t = ee.getCause(); }
            catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
        }
        if (t != null) handleException(t);
    }
    private void handleException(Throwable t) {
        System.err.println("线程池异常:" + t.getMessage());
        // 可记录日志、告警等
    }
}

Q2:ThreadLocal内存泄漏原因与规避

泄漏原理:ThreadLocalMap使用弱引用存储key(ThreadLocal实例),但value为强引用。当ThreadLocal外部引用消失后,key被GC回收,但value仍存在导致泄漏。

规避措施:

  1. 使用完毕后立即调用remove()
  2. 避免在线程池中使用ThreadLocal
  3. 自定义WeakReference包装(高级场景)

线程池使用示例:

public class ThreadLocalPoolDemo {
    private static final ThreadLocal sdf =
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    public static String formatDate(Date date) {
        try { return sdf.get().format(date); }
        finally { sdf.remove(); // 关键:使用后清除
    }
}

Q3:CAS与synchronized性能对比

测试场景:1000次自增操作在不同线程数下的耗时对比(单位:毫秒)

线程数CAS耗时synchronized耗时推荐方案
123任选
458CAS
162215synchronized
6418035synchronized

结论:低竞争场景CAS性能更优,高竞争时synchronized通过自适应锁升级机制更稳定。实际项目中应结合业务特征选择。

〔资源下载〕完整资料与扩展阅读

⑴ 免费下载资源

  • 《java多线程和并发核心知识手册.pdf》——涵盖JUC全部源码解析
  • 《高并发系统设计实战案例集》——含秒杀、ID生成等完整代码
  • 《JVM并发调试指南》——jstack/jcmd线程诊断技巧

下载方式:访问官网www.xservx.com → 点击“资源中心” → 搜索“java多线程和并发pdf”

⑵ 延伸学习路径

  1. 基础巩固:深入理解synchronized与volatile语义
  2. 工具进阶:掌握ForkJoinPool与CompletableFuture
  3. 框架应用:Netty事件循环模型、Spring事务并发控制
  4. 系统设计:分布式锁实现(Redis/ZooKeeper)、消息队列幂等性

💡 实用建议:学习并发编程时务必结合实际业务场景,避免过度设计。建议先掌握线程池配置与基本同步机制,再逐步深入JMM原理。遇到问题优先使用jstack分析线程堆栈,定位阻塞点。