Java并发编程核心专题：锁体系与并发工具类全解析（含关联、原理、实战、选型）

public class SynchronizedDemo {
    private static int staticCount = 0;
    private int instanceCount = 0;
    private final Object lockObj = new Object(); // 自定义不可变锁对象

    // 用法1：修饰实例方法，锁对象为当前this实例，仅作用于当前实例
    public synchronized void instanceMethod() {
        instanceCount++;
        System.out.println("实例方法加锁，count=" + instanceCount);
    }

    // 用法2：修饰静态方法，锁对象为当前类的Class对象，作用于所有实例
    public static synchronized void staticMethod() {
        staticCount++;
        System.out.println("静态方法加锁，count=" + staticCount);
    }

    // 用法3：修饰代码块，手动指定锁对象，粒度最细，推荐优先使用
    public void codeBlockMethod() {
        System.out.println("进入方法，准备加锁");
        synchronized (lockObj) {
            instanceCount++;
            System.out.println("代码块加锁，count=" + instanceCount);
        }
    }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    private int count = 0;
    // 默认非公平锁，吞吐量更高
    private final ReentrantLock nonFairLock = new ReentrantLock();
    // 公平锁：严格FIFO顺序分配锁
    private final ReentrantLock fairLock = new ReentrantLock(true);
    // 多条件变量：实现精准唤醒
    private final Condition oddCondition = nonFairLock.newCondition();
    private final Condition evenCondition = nonFairLock.newCondition();

    // 基础加锁释放
    public void add() {
        nonFairLock.lock();
        try {
            count++;
            System.out.println("计数：" + count);
        } finally {
            nonFairLock.unlock();
        }
    }

    // 超时获取锁：避免无限阻塞
    public boolean tryAdd() {
        try {
            boolean getLock = nonFairLock.tryLock(2, TimeUnit.SECONDS);
            if (!getLock) {
                System.out.println("获取锁超时，放弃执行");
                return false;
            }
            count++;
            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            if (nonFairLock.isHeldByCurrentThread()) {
                nonFairLock.unlock();
            }
        }
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    private String cacheData;
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = (ReentrantReadWriteLock.ReadLock) rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = (ReentrantReadWriteLock.WriteLock) rwLock.writeLock();

    // 读操作：加共享读锁，多线程可并行执行
    public String getData() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 读取数据：" + cacheData);
            return cacheData;
        } finally {
            readLock.unlock();
        }
    }

    // 写操作：加独占写锁，同一时间仅一个线程执行
    public void setData(String newData) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 写入数据：" + newData);
            this.cacheData = newData;
        } finally {
            writeLock.unlock();
        }
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        // 启动3个并行任务线程
        for (int i = 1; i <= 3; i++) {
            final int threadNum = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadNum + " 正在执行任务...");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown(); // 任务完成，计数器减1
                }
            }).start();
        }

        System.out.println("主线程等待所有子任务完成...");
        latch.await(); // 阻塞，直到计数器为0
        System.out.println("所有子任务完成，主线程继续执行！");
    }
}

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        // 3个线程参与，屏障打开时执行汇总任务
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            System.out.println("所有线程已到达屏障，开始汇总结果！");
        });

        for (int i = 1; i <= 3; i++) {
            final int threadNum = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadNum + " 正在计算数据...");
                    Thread.sleep(threadNum * 1000);
                    System.out.println("线程" + threadNum + " 到达屏障，等待其他线程...");
                    barrier.await(); // 阻塞，直到所有线程到达
                    System.out.println("线程" + threadNum + " 继续执行下一阶段任务！");
                } catch (Exception e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    public static void main(String[] args) {
        // 3个许可证（模拟3个数据库连接），公平模式
        Semaphore semaphore = new Semaphore(3, true);

        for (int i = 1; i <= 5; i++) {
            final int threadNum = i;
            new Thread(() -> {
                try {
                    System.out.println("线程" + threadNum + " 尝试获取数据库连接...");
                    semaphore.acquire(); // 获取许可证
                    System.out.println("线程" + threadNum + " 成功获取连接，开始操作数据库...");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    semaphore.release(); // 释放许可证
                    System.out.println("线程" + threadNum + " 释放连接！");
                }
            }).start();
        }
    }
}

import java.util.concurrent.Exchanger;

public class ExchangerDemo {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        // 线程1：发送数据A
        new Thread(() -> {
            try {
                String data1 = "数据A";
                System.out.println("线程1 准备交换数据：" + data1);
                String received = exchanger.exchange(data1);
                System.out.println("线程1 收到数据：" + received);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 线程2：发送数据B
        new Thread(() -> {
            try {
                String data2 = "数据B";
                System.out.println("线程2 准备交换数据：" + data2);
                Thread.sleep(1000);
                String received = exchanger.exchange(data2);
                System.out.println("线程2 收到数据：" + received);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureDemo {
    public static void main(String[] args) {
        // 异步查询用户信息
        CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("查询用户信息完成");
                return "用户ID: 1001";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "查询用户失败";
            }
        });

        // 异步查询订单信息（并行执行）
        CompletableFuture<String> orderFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("查询订单信息完成");
                return "订单号: 2023001";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "查询订单失败";
            }
        });

        // 组合两个任务结果，汇总后输出
        CompletableFuture<Void> resultFuture = userFuture.thenCombine(orderFuture, (user, order) -> {
            return user + " | " + order;
        }).thenAccept(result -> {
            System.out.println("最终汇总结果: " + result);
        });

        resultFuture.join();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class TurnAddDemo {
    private static final int MAX = 1000;
    private static int num = 0;
    private static final ReentrantLock lock = new ReentrantLock();
    // 三个Condition分别对应三个线程，实现精准唤醒
    private static final Condition condition1 = lock.newCondition();
    private static final Condition condition2 = lock.newCondition();
    private static final Condition condition3 = lock.newCondition();
    // 当前应该执行的线程标记：1-线程1，2-线程2，3-线程3
    private static int flag = 1;

    public static void main(String[] args) {
        new Thread(() -> printNum(1, condition1, condition2), "线程1").start();
        new Thread(() -> printNum(2, condition2, condition3), "线程2").start();
        new Thread(() -> printNum(3, condition3, condition1), "线程3").start();
    }

    private static void printNum(int threadFlag, Condition currentCondition, Condition nextCondition) {
        while (true) {
            lock.lock();
            try {
                // 不是当前线程轮次，等待
                while (flag != threadFlag) {
                    if (num >= MAX) break;
                    currentCondition.await();
                }
                if (num >= MAX) {
                    // 唤醒所有线程，避免死锁
                    nextCondition.signal();
                    break;
                }
                num++;
                System.out.println(Thread.currentThread().getName() + " 打印: " + num);
                // 切换到下一个线程
                flag = (threadFlag % 3) + 1;
                // 唤醒下一个线程
                nextCondition.signal();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;

public class ParallelCountDemo {
    // 汇总结果：总偶数个数
    private static int totalEvenCount = 0;
    private static final ReentrantLock lock = new ReentrantLock();
    private static final CountDownLatch latch = new CountDownLatch(4);

    // 统计区间内的偶数个数
    private static void countEven(int start, int end) {
        int count = 0;
        for (int i = start; i <= end; i++) {
            if (i % 2 == 0) {
                count++;
            }
        }
        // 加锁，保证汇总结果的原子性
        lock.lock();
        try {
            totalEvenCount += count;
            System.out.println(Thread.currentThread().getName() + " 统计完成，区间[" + start + "," + end + "]偶数个数：" + count);
        } finally {
            lock.unlock();
        }
        // 计数器减1
        latch.countDown();
    }

    public static void main(String[] args) throws InterruptedException {
        // 启动4个统计线程
        new Thread(() -> countEven(1, 1000), "统计线程1").start();
        new Thread(() -> countEven(1001, 2000), "统计线程2").start();
        new Thread(() -> countEven(2001, 3000), "统计线程3").start();
        new Thread(() -> countEven(3001, 4000), "统计线程4").start();

        // 主线程等待所有统计完成
        System.out.println("主线程等待所有统计线程完成...");
        latch.await();
        System.out.println("所有统计完成，1-4000总偶数个数：" + totalEvenCount);
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class OddEvenPrint {
    private static final int MAX = 100;
    private int num = 0;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition oddCondition = lock.newCondition();
    private final Condition evenCondition = lock.newCondition();

    public void printOdd() {
        while (num < MAX) {
            lock.lock();
            try {
                while (num % 2 == 0) {
                    oddCondition.await();
                }
                System.out.println("奇数线程打印：" + num);
                num++;
                evenCondition.signal();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        }
    }

    public void printEven() {
        while (num < MAX) {
            lock.lock();
            try {
                while (num % 2 == 1) {
                    evenCondition.await();
                }
                System.out.println("偶数线程打印：" + num);
                num++;
                oddCondition.signal();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        OddEvenPrint demo = new OddEvenPrint();
        new Thread(demo::printOdd).start();
        new Thread(demo::printEven).start();
    }
}

import java.util.concurrent.Phaser;

public class PhaserDemo {
    // 定义3个执行阶段
    private static final int TOTAL_PHASE = 3;

    public static void main(String[] args) {
        // 初始注册4个参与线程+1个主线程，共5个
        Phaser phaser = new Phaser(5) {
            // 重写阶段切换钩子函数，每完成一个阶段触发一次
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                System.out.println("========== 第" + (phase+1) + "阶段执行完成，当前参与线程数：" + registeredParties + " ==========\n");
                // 达到总阶段数，返回true终止Phaser
                return phase >= TOTAL_PHASE - 1 || registeredParties == 0;
            }
        };

        // 启动4个工作线程
        for (int i = 1; i <= 4; i++) {
            final int threadNum = i;
            new Thread(() -> {
                // 第一阶段：所有线程都参与
                System.out.println("线程" + threadNum + " 完成第一阶段任务");
                phaser.arriveAndAwaitAdvance(); // 等待所有线程完成第一阶段

                // 第二阶段：线程4注销，不再参与后续阶段
                if (threadNum == 4) {
                    System.out.println("线程" + threadNum + " 完成任务，注销退出");
                    phaser.arriveAndDeregister(); // 到达并注销
                    return;
                }
                System.out.println("线程" + threadNum + " 完成第二阶段任务");
                phaser.arriveAndAwaitAdvance();

                // 第三阶段：仅剩余3个线程参与
                System.out.println("线程" + threadNum + " 完成第三阶段任务");
                phaser.arriveAndAwaitAdvance();
            }, "线程" + i).start();
        }

        // 主线程等待所有阶段完成
        for (int i = 0; i < TOTAL_PHASE; i++) {
            phaser.arriveAndAwaitAdvance();
        }
        System.out.println("所有阶段任务全部执行完成！");
    }
}

public class ThreadLocalDemo {
    // 定义全局ThreadLocal，存储链路traceId
    private static final ThreadLocal<String> TRACE_ID_HOLDER = new ThreadLocal<String>() {
        // 重写初始化方法，默认值为空字符串
        @Override
        protected String initialValue() {
            return "";
        }
    };

    // 模拟业务方法1：无需入参传递traceId，直接从ThreadLocal获取
    private static void serviceMethod1() {
        System.out.println("serviceMethod1执行，当前链路traceId：" + TRACE_ID_HOLDER.get());
        serviceMethod2();
    }

    // 模拟业务方法2：深层链路方法，同样可直接获取
    private static void serviceMethod2() {
        System.out.println("serviceMethod2执行，当前链路traceId：" + TRACE_ID_HOLDER.get());
    }

    public static void main(String[] args) {
        // 模拟3个不同的请求线程，每个线程有独立的traceId
        for (int i = 1; i <= 3; i++) {
            final String traceId = "trace-" + System.currentTimeMillis() + "-" + i;
            new Thread(() -> {
                try {
                    // 线程入口设置traceId
                    TRACE_ID_HOLDER.set(traceId);
                    System.out.println(Thread.currentThread().getName() + " 设置traceId：" + traceId);
                    // 执行业务链路，无需传递traceId
                    serviceMethod1();
                } finally {
                    // 核心：线程执行完毕，必须移除变量，避免内存泄漏
                    TRACE_ID_HOLDER.remove();
                }
            }, "请求线程-" + i).start();
        }
    }
}

import java.util.concurrent.locks.LockSupport;

public class LockSupportDemo {
    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            System.out.println("线程A启动，准备阻塞");
            // 阻塞当前线程，无需加锁
            LockSupport.park();
            System.out.println("线程A被唤醒，继续执行");
        }, "线程A");

        Thread threadB = new Thread(() -> {
            System.out.println("线程B启动，准备唤醒线程A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // 唤醒线程A，先unpark再park也不会失效
            LockSupport.unpark(threadA);
            System.out.println("线程B完成唤醒操作");
        }, "线程B");

        // 先启动线程A，再启动线程B
        threadA.start();
        threadB.start();

        // 测试：先unpark再park，依然有效
        Thread testThread = new Thread(() -> {
            try {
                Thread.sleep(1000);
                System.out.println("测试线程准备调用park");
                LockSupport.park(); // 先被unpark，这里直接放行，不会阻塞
                System.out.println("测试线程park直接放行，执行完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "测试线程");
        testThread.start();
        // 先发放许可，后续park直接放行
        LockSupport.unpark(testThread);
        System.out.println("主线程先调用了unpark，测试线程后续park不会阻塞");
    }
}

private volatile int state;

static final class Node {
    // 节点模式：共享模式、独占模式
    static final Node SHARED = new Node();
    static final Node EXCLUSIVE = null;

    // 节点等待状态
    static final int CANCELLED =  1; // 线程已取消，不再竞争同步状态
    static final int SIGNAL    = -1; // 后继节点处于等待状态，当前节点释放同步状态时需要唤醒后继
    static final int CONDITION = -2; // 节点处于Condition等待队列中
    static final int PROPAGATE = -3; // 共享模式下，唤醒操作需要向后传播

    volatile int waitStatus; // 节点等待状态
    volatile Node prev; // 前驱节点
    volatile Node next; // 后继节点
    volatile Thread thread; // 封装的等待线程
    Node nextWaiter; // Condition等待队列的下一个节点
}

// 队列头节点（哑节点，不存储等待线程）
private transient volatile Node head;
// 队列尾节点
private transient volatile Node tail;

public final void acquire(int arg) {
    // 1. 尝试获取同步状态，成功则直接返回
    if (!tryAcquire(arg) &&
        // 2. 获取失败，将线程封装为Node节点加入等待队列尾部
        // 3. 阻塞等待，被唤醒后重试获取，直到成功
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 4. 获取过程中被中断，设置线程中断标记
        selfInterrupt();
}

public final boolean release(int arg) {
    // 1. 尝试释放同步状态
    if (tryRelease(arg)) {
        Node h = head;
        // 2. 头节点不为空，且等待状态为SIGNAL，需要唤醒后继节点
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

public final void acquireShared(int arg) {
    // 1. 尝试获取共享同步状态，返回值>=0表示成功
    if (tryAcquireShared(arg) < 0)
        // 2. 获取失败，进入队列阻塞等待
        doAcquireShared(arg);
}

public final boolean releaseShared(int arg) {
    // 1. 尝试释放共享同步状态
    if (tryReleaseShared(arg)) {
        // 2. 释放成功，唤醒队列中的等待节点
        doReleaseShared();
        return true;
    }
    return false;
}

# 1. 查看Java进程PID
jps
# 2. 查看线程堆栈，自动检测死锁
jstack <PID>