[Java EE] 多线程编程进阶

[Java EE] 多线程初阶请看下面文章

https://blog.youkuaiyun.com/Boop_wu/article/details/155076865?fromshare=blogdetail&sharetype=blogdetail&sharerId=155076865&sharerefer=PC&sharesource=Boop_wu&sharefrom=from_linkhttps://blog.youkuaiyun.com/Boop_wu/article/details/155076865?fromshare=blogdetail&sharetype=blogdetail&sharerId=155076865&sharerefer=PC&sharesource=Boop_wu&sharefrom=from_link

本文介绍了Java多线程编程中的核心概念与技术，主要包括：

1. 常见锁策略：包括乐观锁/悲观锁、重量级锁/轻量级锁、自旋锁/挂起等待锁等，以及synchronized的自适应锁机制
2. synchronized原理：详细解析其锁升级过程（无锁→偏向锁→轻量级锁→重量级锁）和优化策略（锁消除、锁粗化）
3. CAS机制：深入讲解比较交换操作的实现原理、ABA问题及解决方案
4. JUC工具类：包括Callable接口、ReentrantLock、原子类、信号量等并发工具的使用
5. 线程安全集合：对比分析各种线程安全集合的实现原理和适用场景

文章系统性地讲解了Java并发编程的核心技术，帮助开发者深入理解多线程编程的底层机制和最佳实践

 一.常见的锁策略

1.乐观锁和悲观锁

描述的是加锁时遇到的场景

悲观锁 : 加锁的时候 , 预测接下来的锁竞争会非常激烈 , 就需要针对这种情况进行一些额外的工作

乐观锁 : 加锁的时候 , 预测接下来的锁竞争情况不激烈 , 就不需要额外的工作

注意 : Synchronized 初始使用乐观锁策略 , 但发现竞争比较频繁的时候 , 就会自动切换成悲观锁策略

2.重量级锁和轻量级锁

遇到加锁之后的解决方案

重量级锁 : 加锁机制重度依赖于 OS 的 mutex ; 会有大量的内核态用户切换 , 容易引发线程的调度(一般是用来应对悲观场景下的锁 , 需要付出更多的代价)

轻量级锁 : 加锁机制尽量不再使用 mutex , 而是在用户态代码完成 , 实在搞不定了 , 再使用 mutex ; 会有少量的内核态用户切换 , 不太容易引发线程调度

用户态和内核态 : 是操作系统为权限隔离 , 保障安全而划分的两种 CPU 运行级别, 核心区别在于对硬件/系统资源的访问权限 , 所有进程运行都会在这两种状态之间切换

注意 : synchronized 开始是一个轻量级锁 , 如果锁冲突比较严重 , 就会变成重量级锁

3.挂起等待锁和自旋锁

挂起等待锁 : 获取锁失败后 , 线程放弃 CPU资源 并进入阻塞队列挂起 , 只有锁被释放后才被唤醒(重量级锁的典型实现)

自旋锁 : 获取锁失败后 , 线程不放弃 CPU 并 进入自旋(循环)检测锁是否被释放(轻量级锁的典型实现) (自旋锁的特点是不阻塞线程 , 而是通过循环消耗 CPU 资源来等待锁释放 , 适用于锁竞争不激烈 , 持有时间短的场景)

注意 : synchronized 中的轻量级锁策略大概率是通过自旋锁的方式实现的

总结 :

悲观锁=>重量级锁=>挂起等待锁

乐观锁=>轻量级锁=>自旋锁

synchronzied 针对上述的锁策略是自适应的

4.互斥锁和读写锁

互斥锁 : 任意时刻仅允许一个线程访问临界区(读/写均互斥)

读写锁 : ① 读锁 : 多线程可同时持有(读并发) ; ② 写锁 : 仅一个线程持有(写互斥) ; 可以提高效率 , 减少互斥的机会

Java 标准库中提供了 ReentrantReadWriteLock 类 , 实现了读写锁

• ReenTrantReadWriteLock.ReadLock 类表示一个读锁 , 这个对象提供了 lock/unlock 方法
• ReenTrantReadWriteLock.WriteLock 类表示一个写锁 , 实现了lock/unlock 方法
• 其中 : ① 读加锁和读加锁之间 , 不互斥 ; ② 写加锁和写加锁之间 , 互斥 ; ③ 读加锁和写加锁之间 , 互斥

注意 : synchronized 不是读写锁

5.可重入锁和不可重入锁

可重入锁 : 允许同一线程多次获取同一把锁(递归锁) ; 内部机制 : 维护 [ 线程归属标记+锁计数器 ] , 解锁需要计数器归 0

不可重入锁 : 同一线程持有锁时 , 再次请求锁会阻塞/死锁

在 Java 中只要以 Reentrant 开头命名的锁都是可重入锁 , 而且 JDK 提高的所有现成的 Lock 实现类 , 包括 synchronized 关键字锁都是可重入的 ; 而 Linux 系统中提供的 mutex 时不可重入的

注意 : synchronized 是可重入锁

6.公平锁和非公平锁(针对插队现象的公平和非公平)

公平锁 : 按照线程等待的先后顺序获取锁 , 先等待的线程先执行

非公平锁 : 线程请求锁时直接尝试抢锁 , 抢不到再进入等待队列(机会均等)

Java 标准库中

公平锁 : ReentrantLock(true) ,

非公平锁 : ReentrantLock(false)/synchronized

注意 :

synchronized 是非公平锁

操作系统内部的线程调度就可以视为随机的 , 如果不做任何额外的限制 , 锁就是非公平锁 , 如果想要实现公平锁 , 就需要依赖额外的数据结构 , 来记录线程的先后顺序

二.synchronized 原理

1.核心特性

可重入 , 非公平 , 隐式加锁/解锁(JVM 自动处理)

2.锁升级

无锁 => 偏向锁 => 轻量级锁=> 重量级锁

注意 : 锁升级是单项的(只能从低到高) , 无法降级(不会从重量级到轻量级)

① 无锁

此时没有锁竞争 , 无需加锁

② 偏向锁(Biased Lock) -- 单线程无竞争场景

目标 : 消除单线程重复加锁的开销(仅第一次加锁有少量开销)

• 加锁逻辑 :

• 解锁逻辑 :

③ 轻量级锁(Lightweight Lock) -- 多线程交替竞争场景

目标 : 用 CAS 自旋代替内核态阻塞 , 减少上下文切换开销

触发条件 : 有多个线程竞争偏向锁 , JVM 撤销偏向锁 , 升级为轻量级锁

• 加锁逻辑 :

• 解锁逻辑 :

④ 重量级锁(Heavuweight Lock) -- 多线程持续竞争场景

目标 : 通过操作系统内核态的监视器锁保证互斥 , 牺牲性能换取稳定性

触发条件 : 轻量级锁自旋次数达到阈值 , 或多个线程同时自旋 , JVM 升级为重量级锁

• 加锁逻辑 :

• 监视器锁 :

3.其他锁优化

1.锁消除(Lock Elimination) - 移除"无竞争的锁"

JVM 的 JIT 编译器通过逃逸分析判断 : 若锁对象是线程私有的 , 则该线程不存在线程并发竞争 , JIT 会在编译阶段自动移除该锁的加锁操作

代码示例 :

① 局部变量作为锁对象

public void lockEliminationDemo() {
    // 锁对象：局部变量 lockObj，仅当前线程可见（无逃逸）
    Object lockObj = new Object();
    
    synchronized (lockObj) { // JIT 会消除此锁
        System.out.println("无竞争的同步代码块");
    }
}

优化后 :

public void lockEliminationDemo() {
    Object lockObj = new Object();
    System.out.println("无竞争的同步代码块"); // 锁被消除
}

②JDK 内置类的隐式锁消除

StringBuffer 的 append() 方法是同步方法（加了 synchronized），但如果 StringBuffer 是局部变量（无逃逸），JIT 会消除锁：

public String stringBufferDemo() {
    // sb 是局部变量，无逃逸
    StringBuffer sb = new StringBuffer();
    sb.append("Java"); // 同步方法，锁被消除
    sb.append("Lock"); // 同步方法，锁被消除
    return sb.toString();
}

sb 仅在当前方法内使用，无其他线程竞争，JIT 消除 append() 方法的 synchronized 锁，性能等同于 StringBuilder

2. 锁粗化(Lock Coarsening) - 合并细粒度锁

当 JIT 检测到同一个锁对象被频繁,连续地加锁解锁 (如循环内加锁 , 连续调用同步方法) , 会见多次加解锁操作合并为一次 , 减少锁操作对底层的开销

代码示例 :

① 循环内细粒度的锁          

'public class demo38 {
    private static int count = 0;
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (locker){
                    count++;
                }synchronized (locker){
                    count++;
                }synchronized (locker){
                    count++;
                }
            }
        });
    }
}

优化后

public class demo38 {
    private static int count = 0;
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (locker){
                    count++;
                    count++;
                    count++;
                }
            }
        });
    }
}

注意 : JIT 不会无限制的粗化锁 : 若合并后的锁持有时间过长 , 可能导致其他线程长期阻塞 , JIT 会平衡 加解锁次数 和 持有锁时间 , 仅对短时间内连续的锁操作进行粗优化

维度	synchronized	ReentrantLock
锁类型	隐式锁（JVM 自动管理）	显式锁（手动 lock ()/unlock ()）
公平性	仅非公平锁	可配置公平 / 非公平锁
锁升级	自动（无锁→偏向→轻量→重量）	无锁升级，默认非公平，底层依赖 CAS+AQS
功能扩展	无（仅基础加锁 / 解锁）	支持可中断锁、超时锁、条件变量（Condition）

三.CAS(Compara And Swap)

CAS (比较和交换)是 Java 实现无锁并发编程的核心底层机制 , 属于乐观锁的实现 , 通过 CPU 原子指令保证操作的原子性 , 无需传统锁(如 synchronized)的阻塞/唤醒开销

1.核心操作

• 一个 CAS 涉及到的操作 : 若内存地址 V 的值 == 预期值 A , 则将 V 更新为 B , 返回 true ; 否则不操作 , 返回 false
• 硬件层面的 CPU 原子指令 , JVM 通过 Unsafe 类调用底层指令 , 保证"比较 - 交换" , 不可中断 ; 当多个线程同时对某个资源进行 CAS 操作时 , 只能有一个线程操作成功 , 但是并不会阻塞其他线程 , 其他线程只会收到操作失败的信号

1. check and set
2. read and update

一个伪代码

参数 : 内存地址(要操作变量的内存地址) , 预期值(变量的旧值) , 新值

booleanCAS(address, expectValue, swapValue) {
    if (&address == expectedValue) { 
        &address = swapValue; 
        return true; 
    } 
    return false; 
}

2.应用

① 是java.util.concurrent.atomic 包

import java.util.concurrent.atomic.AtomicInteger;

public class demo39 {
    private static AtomicInteger count = new AtomicInteger(0);//赋初始值为0
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count.getAndIncrement();//count++;
                //count.incrementAndGet();//++count;
                //count.addAndGet(4);//count+=4;
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count.getAndIncrement();//count++;
                //count.incrementAndGet();//++count;
                //count.addAndGet(4);//count+=4;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = " +count);
    }

}

② 基于 CAS 实现自旋锁

伪代码

public class SpinLock { 
    private Thread owner = null; 
    public void lock(){ 
        // 通过 CAS 看当前锁是否被某个线程持有. 
        // 如果这个锁已经被别的线程持有, 那么就⾃旋等待. 
        // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程. 
        while(!CAS(this.owner, null, Thread.currentThread())){
            
        } 
    } 
    public void unlock (){
        this.owner = null; 
    }
}

若 owner 为 null(锁未被持有) , 则将其设为当前线程 ; 若锁已经被其他线程持有 , 则通过 while 循环自旋等待

3.ABA 问题

① 问题描述 :

线程 1 操作是 [初始值A => 经过修改操作值为B] ; 线程 2 的操作是 [数是指为 A => 修改为 C => 又退回 A] ; 此时线程 1 执行 CAS 时 , 检测到变量仍然为 A , 误以为未被修改 , 会再次将其更新为 B

② 问题核心 :

CAS 仅校验最终值 , 忽略中间修改

③ 解决方案 :

引入版本号 , 在 CAS 比较数据当前值和旧值的同时 , 也要比较版本号是否符合预期

当真正修改的时候 , 如果当前版本号 与 读到的版本号相同 , 则修改数据 , 并把版本号+1 , 如果当前版本号高于读到的版本号 , 就操作失败(认为数据已经被修改过了)

4.仅支持单个变量原子操作 问题

① 问题描述 :

CAS 只能保证单个变量操作的原子性 , 无法直接实现多变量的原子更新(如同时更新 a 和 b)

② 解决方案 :

        合并变量 : 将多个变量合并为一个对象 , (通过 AtomicReference 操作对象引用);

import java.util.concurrent.atomic.AtomicReference;

class MulNum{
    int a;
    int b;
    public MulNum(int a,int b){
        this.a = a;
        this.b = b;
    }
}
public class demo40 {
    private static AtomicReference<MulNum> count = new AtomicReference<>(new MulNum(1,2));

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread t1 = new Thread(()->{
                while(true){
                    MulNum oldVar = count.get();
                    MulNum newVar = new MulNum(oldVar.a + 1, oldVar.b + 1);
                    if(count.compareAndSet(oldVar,newVar)){
                        System.out.println("更新后：a=" + newVar.a + ", b=" + newVar.b);
                        break;
                    }
                }
            });
            t1.start();
        }
    }
}

        实现互斥锁(ReentrantLock 为例)

import java.util.concurrent.locks.ReentrantLock;

public class demo41 {
    private int a = 1;
    private int b = 2;
    private ReentrantLock lock = new ReentrantLock();

    public void updateMultiVar() {
        lock.lock();
        try {
            a++;
            b++;
            System.out.println("更新后：a=" + a + ", b=" + b);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        demo41 demo = new demo41();
        for (int i = 0; i < 5; i++) {
            new Thread(demo::updateMultiVar).start();
        }
    }
}

 四.JUC(java.util.concurrent) 常见类

Java 并发编程中的 JUC 是处理高并发场景的核心工具包 , 解决了原生 synchronized,wait/notify 等机制的局限性 , 包含了线程池 , 锁 , 原子锁 , 并发集合 , 同步器等核心组件

1. 原生并发编程的痛点：

• Runnable 无返回值，无法抛出受检异常
• synchronized 是隐式锁，无法中断、无法超时、只有非公平锁
• Vector/Hashtable 等同步集合性能差
• 手动管理线程（创建 / 销毁）开销大等

JUC 的核心目标 : 更灵活的同步控制、更高的并发性能、更简洁的异步编程

2.Callable 接口

Callable 是 JUC 包下的函数式接口 , 核心作用 : 定义有返回值 , 可抛异常的线程 ; 弥补了 Runnable 接口的不足 , 是多线程异常执行并获取结果的核心工具

示例:创建线程计算1+2+3+...+1000

① 如果不使用 callable:

public class demo43 {
    private static volatile int result = 0;

    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker){
                for (int i = 1; i < 100; i++) {
                    result+=i;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                locker.notify();
            }

        });
        Thread t2 = new Thread(()->{
            synchronized (locker) {
                try {
                    while (result == 0) {
                        locker.wait();
                    }
                    System.out.println("result = " + result);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();//恢复线程中断状态
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
    }
}

或

public class Demo {
    // 封装结果和锁对象的内部类
    static class Result {
        public int sum = 0;
        public Object lock = new Object();
    }

    public static void main(String[] args) throws InterruptedException {
        Result result = new Result();

        // 线程t：计算1-1000的累加和
        Thread t = new Thread() {
            @Override
            public void run() {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                // 必须在同步块内操作锁和结果
                synchronized (result.lock) {
                    result.sum = sum;
                    result.lock.notify(); // 持有锁时调用notify
                }
            }
        };
        t.start();

        // 主线程：等待计算完成，打印结果
        synchronized (result.lock) {
            // 循环判断（防虚假唤醒）+ 修正"=="
            while (result.sum == 0) {
                result.lock.wait();
            }
            System.out.println("1-1000的累加和：" + result.sum); // 输出500500
        }
    }
}

显然上述的代码操作复杂 , 容易出错

② 使用 Callable 的版本(优化)

• 创建一个匿名内部类，实现 Callable 接口.Callable 带有泛型参数。泛型参数表示返回值的类型
• 重写 Callable 的 call 方法，完成累加的过程。直接通过返回值返回计算结果
• 把 callable 实例使用 FutureTask 包装一下
• 创建线程，线程的构造方法传入 FutureTask. 此时新线程就会执行 FutureTask 内部的 Callable 的 call 方法，完成计算。计算结果就放到了 FutureTask 对象中
• 在主线程中调用 futureTask.get () 能够阻塞等待新线程计算完毕。并获取到 FutureTask 中的结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class demo42 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.此处Callable只是定义了一个带有返回值的任务 , 并没有在执行
        //执行还是需要搭配Thread对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result = 0;
                for(int i = 1;i<100;i++){
                    result+=i;
                }
                return result;
            }
        };
        //2.封装为FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        //3.创建线程
        Thread t = new Thread(futureTask);
        //4.启动线程
        t.start();
        System.out.println(futureTask.get());//此处只有get执行完毕,才能拿到返回结果,可能会陷入阻塞
    }
}

3.ReentrantLock

可重入互斥锁 , 和 synchronized 定位类似 , 都是用来实现互斥效果的 , 保证线程安全

①常用方法

void lock()	加锁;①若锁空闲,立即获取锁,锁计数器+1 ; ②若锁被占用,当时线程阻塞,直到获取锁
void unlock()	解锁;①锁计数器-1 ; ②计数器归0,释放锁,唤醒等待队列线程(必须在 finally 中调用)
void lockInterruptibly()	可中断锁;与 lock()逻辑一致 ; 等待锁是,线程若被中断,抛 InterruptedException(中断线程后需要恢复)(Thread.currentThread().interrupt();)
boolean tryLock()	尝试加锁;①锁空闲->获取锁,返回true ; ② 锁被占用->立即返回 false
boolean tryLock(long timeout, TimeUnit unit)	超时加锁;①在指定时间内尝试获取锁； ②超时 / 被中断→返回 false

示例 :

import java.util.concurrent.locks.ReentrantLock;

public class Demo44 {
    private static int count = 0;

    public static void main(String[] args) {
        // 开启公平锁（true），默认非公平锁（false）
        ReentrantLock locker = new ReentrantLock(true);

        Thread t1 = new Thread(() -> { // 简化Lambda写法
            for (int i = 0; i < 50000; i++) {
                locker.lock(); // 获取锁（阻塞直到拿到锁）
                try {
                    count++; // 临界区：原子操作
                } finally {
                    locker.unlock(); // 必须放finally，确保锁释放
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                locker.lock();
                try { // 修复：t2的unlock移到finally
                    count++;
                } finally {
                    locker.unlock();
                }
            }
        });

        t1.start();
        t2.start();

        try {
            // 等待t1、t2执行完毕，避免主线程提前打印结果
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            // 中断后恢复中断状态（规范做法）
            Thread.currentThread().interrupt();
        }

        System.out.println("Final count: " + count); // 预期输出 100000
    }
}

注意 :

1. ReentrantLock locker = new ReentrantLock(true);是一个公平锁的实例 ; 可以 保证先得到的先执行,每个线程最终都能获取锁 , 不会出现饥饿问题 ; 但是公平锁需要维护等待队列的有序性 , 即使临时锁空闲 , 也不会让请求的线程"插队" , 必须唤醒队列的头部线程 , 导致上下文切换增多 , 最终导致性能损耗大
2. locker.lock();放在 try{}外面 ; 会有风险如果 lock() 执行时抛出异常（比如 lockInterruptibly() 被中断、或 JVM 异常），lock() 并未成功获取锁，但 finally 块会无条件执行 unlock(); 此时当前线程未持有锁，调用 unlock() 会直接抛出 IllegalMonitorStateException，导致程序崩溃

② 总结创建线程的写法 :

1. 继承 Thread 类(单独定义类/匿名内部类)
2. 实现 Runnable 接口(定义单独类/匿名内部类)
3. lambda
4. 实现 Callable 接口(单独定义类/匿名内部类)
5. 线程池 ThreadFactory

③ReentrantLock 和 synchronized 的区别

1. synchronized 是一个关键字 , 是 JVM 内部实现的(基于 C++) ; ReentrantLock 是标准库的一个类 , 在 JVM 外部实现(基于 Java)
2. synchronized 使用时不需要手动释放锁 ; ReentrantLock 使用时需要手动释放 , 使用起来更灵活 , 但也更容易遗漏 unlock()
3. synchronized 在申请锁失败时 , 会死等 ; ReentrantLock 可以通过 tryLock 的方式等待一段时间就放弃
4. synchronized 是非公平锁 ; ReentrantLock 默认是非公平锁 , 可以通过构造方法传入一个 true 开启公平锁 (ReentrantLock locker = new ReentrantLock(true);)
5. synchronized 是通过 Object 的 wait/notify 来实现等待-唤醒 , 每次唤醒的是一个随机等待的线程 ; ReentrantLock 搭配 Condition 类实现等待-唤醒 , 可以精准控制唤醒某个指定的线程
6. synchronized 可以不支持查询锁状态 ; ReentrantLock 支持isLocked()/isHeldByCurrentThread()等查询锁状态
7. synchronized 不可中断锁(获取锁时线程会一直阻塞) ; ReentrantLock 可中断锁(lockInterruptibly())
8. 都是可重入锁

Condition 类示例 :

ReentrantLock lock = new ReentrantLock();
Condition conditionA = lock.newCondition(); // 条件A
Condition conditionB = lock.newCondition(); // 条件B

// 线程1等待条件A
lock.lock();
try {
    conditionA.await();
} finally {
    lock.unlock();
}

// 线程2唤醒等待条件A的线程
lock.lock();
try {
    conditionA.signal(); // 仅唤醒等待条件A的线程
} finally {
    lock.unlock();
}

lockInterruptibly() 可中断锁示例:

Thread t = new Thread(() -> {
    try {
        lock.lockInterruptibly(); // 可中断获取锁
    } catch (InterruptedException e) {
        System.out.println("线程被中断，放弃获取锁");
        return;
    }
    try {
        // 临界区
    } finally {
        lock.unlock();
    }
});
t.start();
t.interrupt(); // 中断线程，触发 InterruptedException

4.原子类

在前面 CAS 中提到过原子类 , 此处结合上一篇来讲

原子类是java.util.concurrent.atomic 包下的一组工具类 , 基于 CAS 机制实现无锁化的线程安全操作 , 避免锁竞争和上下文切换

① 原子类分类

类别	核心类	用途
基本类型原子类	AtomicInteger、AtomicLong、AtomicBoolean	原子更新int / long / boolean 类型
引用类型原子类	AtomicReference、AtomicStampedReference	原子更新对象引用（解决 ABA 问题）
数组类型原子类	AtomicIntegerArray、AtomicLongArray	原子更新数组中的元素
字段更新器原子类	AtomicIntegerFieldUpdater、AtomicReferenceFieldUpdater	原子更新对象的非静态字段（需 volatile 修饰）

② 基本类型原子类

此处以 AtomicInterger 为例

方法	功能
get()	获取当前值
set(int newValue)	设置新值（非原子，仅赋值）
getAndSet(int newValue)	原子设置新值，返回旧值
compareAndSet(int expect,int update)	CAS 更新：预期值匹配则更新，返回是否成功
getAndIncrement()	原子自增（i++），返回旧值
incrementAndGet()	原子自增（++i），返回新值
getAndAdd(int delta)	原子累加 delta，返回旧值
addAndGet(int delta)	原子累加 delta，返回新值

示例 :

import java.util.concurrent.atomic.AtomicInteger;

public class demo45 {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger count = new AtomicInteger(0);
        for(int i = 0;i<10;i++){
            Thread t1 = new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    count.incrementAndGet();//count++;

                }
            });
            t1.start();
        }
        Thread.sleep(1000);
        System.out.println("count = "+count);
    }
}

③ 引用类型原子类

• AtomicReference：原子更新对象引用（如自定义对象）
• AtomicStampedReference：带版本号的原子引用，解决 CAS 的 ABA 问题
• AtomicMarkableReference：带标记的原子引用（标记值为 boolean，简化版版本号）

示例 :

import java.util.concurrent.atomic.AtomicStampedReference;

public class demo46 {
    public static void main(String[] args) {
        // 线程1：将 A→B→A（模拟 ABA 场景）
        AtomicStampedReference<String> ars = new AtomicStampedReference<>("A",1);
        Thread t1 = new Thread(()->{
            int stamp = ars.getStamp();//获取版本号
            ars.compareAndSet("A","B",stamp,stamp+1);
            ars.compareAndSet("A","B",stamp+1,stamp+2);


        });
        t1.start();

        // 线程2：CAS 更新，需匹配引用+版本号
        Thread t2 = new Thread(()->{
            int stamp = ars.getStamp(); // 初始版本号 1
            // 版本号不匹配（实际已变为 2），更新失败
            boolean success = ars.compareAndSet("A", "C", stamp, stamp + 1);
            System.out.println("更新是否成功：" + success); // false
            System.out.println("当前值：" + ars.getReference()); // A
            System.out.println("当前版本号：" + ars.getStamp()); // 2
        });
        t2.start();

    }
}

④ 数组原子类

AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray：原子更新数组中的元素（数组本身是普通数组，仅元素操作原子化）

示例 :

import java.util.concurrent.atomic.AtomicIntegerArray;

public class demo47 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        AtomicIntegerArray atomicArr = new AtomicIntegerArray(arr);

        // 原子更新索引 1 的元素（2→20）
        atomicArr.compareAndSet(1, 2, 20);
        System.out.println(atomicArr.get(1)); // 20

        // 原子自增索引 0 的元素（1→2）
        atomicArr.getAndIncrement(0);
        System.out.println(atomicArr.get(0)); // 2
    }
}

⑤ 字段更新器原子类

AtomicIntegerFieldUpdater/AtomicLongFieldUpdater/AtomicReferenceFieldUpdater：原子更新对象的非静态字段（需满足 2 个条件）：

• 字段必须用 volatile 修饰（保证可见性）
• 字段的访问权限：若更新器在外部类，字段需为 public/protected，或通过反射突破访问限制

示例 :

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class demo48 {
    public static void main(String[] args) {
        class User {
            // 必须用 volatile 修饰
            volatile int age;
            public User(int age) {
                this.age = age;
            }
        }

        // 创建字段更新器（参数：类、字段名）
        AtomicIntegerFieldUpdater<User> updater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

        User user = new User(18);
        // 原子自增 age（18→19）
        updater.getAndIncrement(user);
        System.out.println(user.age); // 19

        // CAS 更新 age（19→20）
        updater.compareAndSet(user, 19, 20);
        System.out.println(user.age); // 20
    }
}

5.Semaphone 信号量

Java 中的 Semaphone 是 juc 包下的并发工具类 , 核心作用 : 控制同时访问某个资源的线程数量 , 本质是 通过维护一个"许可(permits)"计数器实现限流 / 资源管控 , 是实现"优先资源共享" 的经典方案

核心逻辑 :

Semaphone 是基于 AQS(抽象队列同步器)实现的

1. 初始化时指定许可数(允许同时访问的线程数)
2. 线程通过 acquire()获取许可 : 许可次数>0 则-1,且线程继续执行 ; 许可数 = 0 则线程阻塞,直到其他线程释放许可
3. 线程通过 release()释放许可 : 许可数+1 , 唤醒等待队列中的线程

示例 :

import java.util.concurrent.Semaphore;

public class demo49 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(3);
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
        semaphore.acquire();
        System.out.println("进行一次 P 操作");
    }
}

应用 : 当初始值为 1 的信号量(二元信号量) , 等价于锁(不可重入锁)

import java.util.concurrent.Semaphore;

public class demo50 {
    private static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(1);
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 10000; i++) {
                try {
                    semaphore.acquire();
                    count++;
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    try{
                        semaphore.acquire();
                        count++;
                        semaphore.release();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = "+count);
    }
}

6.CountDownLatch

是 JUC 的同步辅助工具类 , 核心作用 : 让一组线程等待其他线程完成指定操作后 , 再继续执行

核心原理 :

1. 初始化计数器 : 创建 CountDownLatch 时指定计数器初始值
2. 线程等待 : 调用 await()的线程会阻塞 , 直到计数器值减为 0;
3. 计数器递减 : 完成任务的线程调用 countDown() , 将计数器值减为 1;
4. 放弃等待线程 : 但计数器值减为 0 时 , 所有调用 await()的线程被唤醒 , 继续执行

注意 : 计数器只能递减 , 无法重置(一旦减为 0 , 后续调用 countDown()无效果 , await()也会立即返回)

示例 :

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

public class demo57 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(10);
        ExecutorService executor = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 10; i++) {
            int id = i;
            executor.submit(() -> {
                System.out.println("子任务开始执行: " + id);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("子任务结束执行: " + id);
                latch.countDown();
            });

        }
        latch.await();//这个方法阻塞等待所有的任务结束
        System.out.println("所有线程执行完毕");
        executor.shutdown();
        /***
         * ①创建计数为 10 的 CountDownLatch，表示需要等待 10 个子任务完成；
         * ②用 4 核心的线程池批量提交 10 个子任务，每个任务执行 1 秒后调用 countDown() 递减计数器；
         * ③主线程调用 latch.await() 阻塞，直到 10 个任务全部完成（计数器归 0）；
         * ④最后输出提示并关闭线程池。
         */

    }
}

五.Java 中线程安全的集合类

线程安全的集合类 , 其核心解决普通集合(如 ArrayList/HashMap)在并发读写时的数据错乱 , ConcurrentMidificationException , 此循环等问题

1.线程安全集合的核心分类

分类	实现原理	代表类	核心特点
同步包装类	Collections.synchronizedXxx()	synchronizedList/synchronizedMap	全局加锁(synchronized),简单但并发性能低
JUC 并发集合	分段锁 / CAS / 写时复制 / 阻塞队列	ConcurrentHashMap/CopyOnWriteArrayList/LinkedBlockingQueue	精细化锁 / 无锁设计，高并发下性能更优

2.多线程下使用 ArrayList

① 自己使用同步机制(synchronized 或 ReentrantLock)

此处不再说

② 通过 Collection 工具类为普通集合套上 [ 全局锁 ]

本质是对集合所有方法加 synchronized

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

注意 : 迭代时需要手动加锁 , 否则抛异常(ConcurrentMidificationException)

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

public class demo1 {
    public static void main(String[] args) throws InterruptedException {
        //多线程下的ArraryList
        List<String> syncList = Collections.synchronizedList(new ArrayList<>());
        syncList.add("Hello");
        syncList.add("World");
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncList.add("Java");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                syncList.add("Thread");
            }
        }).start();
        Thread.sleep(1000);
        synchronized (syncList) {//必须锁定集合对象本身
            for (String s : syncList) {
                System.out.println(s);
            }

        }

    }
}

③ 使用 JUC 包 , CopyOnWriteArrayList

核心实现 :

• 写操作 : (add/remove/set) 复制一份新的数组 , 在数组上修改 , 修改完成后替换原数组 , 全程加锁
• 读操作 : (get/iterator) 直接读原数组 , 无锁 , 性能极高

常见问题 :

问题 1 : 写操作性能地 , 内存开销大

解决方案 : 仅用于都铎写少的场景 ; 当频繁场景时改用 ReentrantLock 手动加锁的普通 List

问题 2 : 迭代过程中其他线程的修改不会反映到迭代器中

解决方案 : 需要加锁 ; 或者每次迭代前重新获取集合

3.多线程使用队列

① ArrayBlockingQueue

基于数组实现的阻塞队列

② LinkedBlockingQueue

基于链表实现的阻塞队列

③ PriorityBlockingQueue

基于堆实现的带优先级的阻塞队列

④ TransferQueue

最多只包含一个元素的阻塞队列

4.多线程使用哈希表

在多线程下使用哈希表(键值对储存) , 核心问题是解决线程安全和并发性能--普通 HashMap 线程不安全 , 并发读写会导致数据错乱 , 死循环 , ConcurrentModificationException 等问题

① 线程安全哈希表

类型	代表类	实现原理
全局锁哈希表	Hashtable/ Collections.synchronizedMap	所有方法加 synchronized;全局锁
精细化锁哈希表	ConcurrentHashMap	JDK1.7:分段锁;JDK1.8:CAS + 局部synchronized
写时复制哈希表	ConcurrentSkipListMap(有序)	跳表 + CAS，无锁设计

②Hashtable(低效)

只是简单的把关键的方法加上了 synchronized

这相当于直接对 Hashtable 对象本身加锁

• 如果多线程访问同一个 Hashtable 就会直接造成锁冲突
• 一旦触发扩容 , 就由该线程完成整个扩容过程

注意 : Hashtable 是 JDK1.0 的老旧类 , 性能差 , 已被ConcurrentHashMap 完全替代 , 仅作为了解

②ConcurrentHashMap(首选)

核心原理 : 抛弃了 JDK1.7 的分段锁(把这些链表分成几组 , 每个组安排一个锁) , 改用更细粒度的锁机制 (锁桶)

• 读操作 : 无锁 , 通过 volatile 保证数据可见性
• 写操作 : 1)对空桶 : CAS 原子操作写入 , 无锁 ; 2) 对非空桶 : 对桶首届点加 synchronized 锁 , 仅阻塞当前桶的读写 , 其他桶可并发
• 当桶元素超过 8 个转为红黑树 , 提升查找性能

private static final Map<String, Integer> map = new ConcurrentHashMap<>();

扩容机制 : 化整为零

• 发现扩容的线程只创建新数组,搬几个元素 : 1) 触发扩容的线程先标记 , 并且创建新数组(容量翻倍) ; 2) 按步长 (16)拆分原数组 , 该线程仅迁移自己负责的一小段桶(目的:避免的那现场一次迁移所有元素导致长时间阻塞)
• 扩容期间新老数组同时存在 : 1)新数组作为全局变量 , 扩容全程与老数组共存 ; 2)迁移完成的桶做标记 , 未迁移的桶仍在老数组中(保证连续性)
• 后续线程搬家 , 各搬一小部分 : 1)任何线程执行 put/remove 时 , 若检测到扩容中 , 会先暂停自身操作 , 协助迁移 ; 2)每个线程仅迁移自己"认领的桶段"(避免重复)
• 搬完最后一个元素删除老数组 : 1)所有桶迁移完成 , 主线程将老数组替换成新数组 , 并删除 (释放内存); 2)更新扩容阈值 , 并标记扩容完成
• 插入只往新数组加 : 扩容期间 , put 操作先检查桶是否已经迁移 , 若已迁移 : 直接写入新数组 , 若未迁移 : 先协助迁移 , 再写入新数组(防止老数组数据冗余)
• 查找需同时查找新老数组 : get 操作 , 先查老数组 , 若桶已迁移完(标记) , 则跳转到行数则查询 ; 若桶未迁移 : 直接查询老数组 ; 若新老数组都查不到 , 再返回 null(保证扩容期间读取数据不丢失 , 不遗漏)