别只知道锁！Java并发编程中的“神器”工具，让你告别多线程烦恼

别只知道锁！Java并发编程中的“神器”工具，让你告别多线程烦恼

“喂，哥们，最近在搞啥呢？”

“别提了，多线程，搞得我头都大了！”

“哈哈，多线程确实挺烦的，不过你是不是只知道用锁啊？”

“锁？synchronized、ReentrantLock 这些我还是知道的，难道还有别的？”

“当然有啦！Java 并发编程可是一座宝库，除了锁，还有很多‘神器’级别的工具呢！今天我就来给你好好说道说道，保证让你对 Java 并发编程有全新的认识！”

1. 锁：并发编程的“老朋友”

在咱们深入了解其他工具之前，先简单回顾一下锁。毕竟，锁是咱们接触并发编程时最早认识的“老朋友”了。

锁，顾名思义，就是用来控制多个线程对共享资源访问的一种机制。当一个线程获得了锁，其他想要访问该资源的线程就只能乖乖排队等着，直到这个线程释放锁。

Java 中主要有两种类型的锁：

• synchronized: 这是 Java 内置的锁，也叫隐式锁。它使用起来比较简单，只需要在方法或代码块上加上 synchronized 关键字即可。但是，synchronized 锁的功能相对有限，例如无法实现公平锁、读写锁等。
• ReentrantLock: 这是 java.util.concurrent 包提供的显式锁。ReentrantLock 提供了比 synchronized 更丰富的功能，例如可以实现公平锁、非公平锁、可重入锁、可中断锁等。ReentrantLock 的使用需要手动获取锁和释放锁。

“等等，你刚才说公平锁、非公平锁、可重入锁、可中断锁，这些都是啥意思？”

别急，我给你举几个例子你就明白了：

• 公平锁/非公平锁： 想象一下你去银行排队办业务，公平锁就像是先来后到，谁先排队谁先办理；非公平锁就像是 VIP 通道，即使你来得晚，也可能比别人先办理。在 Java 中，ReentrantLock 可以通过构造函数参数来选择创建公平锁还是非公平锁，默认是非公平锁。
• 可重入锁： 想象一下你拿着钥匙进了家门，然后又去开卧室门，如果这把钥匙能同时打开家门和卧室门，这就是可重入锁。在 Java 中，synchronized 和 ReentrantLock 都是可重入锁，也就是说同一个线程可以多次获取同一把锁。
• 可中断锁： 想象一下你正在排队等候，突然接到一个紧急电话需要立即离开，如果这个队伍允许你插队离开，这就是可中断锁。在 Java 中，ReentrantLock 提供了 lockInterruptibly() 方法，可以在等待锁的过程中响应中断。

“哦，原来如此！看来锁的学问还真不少呢！”

“那是当然！不过，锁虽然好用，但也不是万能的。在某些场景下，锁可能会导致性能问题，甚至死锁。所以，Java 并发编程还提供了其他一些工具，来帮助我们更好地处理并发问题。”

2. Semaphore：控制并发线程数的“信号灯”

“除了锁，还有什么工具呢？”

“接下来要介绍的这位，叫做 Semaphore，你可以把它想象成一个控制并发线程数的‘信号灯’。”

Semaphore，中文名叫信号量，它可以控制同时访问某个资源的线程数量。你可以把它想象成一个停车场，停车场有固定数量的车位，只有当有空闲车位时，车辆才能进入停车场。Semaphore 的主要方法有：

• acquire(): 获取一个许可，如果没有可用的许可，线程就会阻塞，直到有许可可用。
• release(): 释放一个许可，将许可归还给 Semaphore。

“这个 Semaphore 有什么用呢？”

“用处可大了！比如，你可以用 Semaphore 来限制数据库连接的数量，防止同时创建过多的连接导致数据库崩溃；你还可以用 Semaphore 来控制线程池中执行任务的线程数量，防止线程过多导致系统资源耗尽。”

下面是一个使用 Semaphore 控制数据库连接数量的例子：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.concurrent.Semaphore;

public class DatabaseConnectionPool {

    private static final int MAX_CONNECTIONS = 10;
    private static final Semaphore semaphore = new Semaphore(MAX_CONNECTIONS);
    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/mydatabase";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException, InterruptedException {
        semaphore.acquire(); // 获取一个许可
        Connection connection = null;
        try {
            connection = DriverManager.getConnection(JDBC_URL, USERNAME, PASSWORD);
        } catch (SQLException e) {
            semaphore.release(); // 如果连接创建失败，释放许可
            throw e;
        }
        return connection;
    }

    public static void releaseConnection(Connection connection) throws SQLException {
        if (connection != null) {
            connection.close();
            semaphore.release(); // 释放许可
        }
    }

    public static void main(String[] args) {
        // 模拟多个线程获取数据库连接
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                try {
                    Connection connection = getConnection();
                    // 使用连接执行数据库操作...
                    System.out.println(Thread.currentThread().getName() + " 获取到数据库连接");
                    Thread.sleep(1000); // 模拟数据库操作耗时
                    releaseConnection(connection);
                    System.out.println(Thread.currentThread().getName() + " 释放数据库连接");
                } catch (SQLException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

在这个例子中，我们创建了一个 Semaphore，并设置了最大许可数为 10，也就是最多允许同时创建 10 个数据库连接。每个线程在获取数据库连接之前，都需要先调用 semaphore.acquire() 方法获取一个许可，如果没有可用的许可，线程就会阻塞。当线程使用完数据库连接后，需要调用 semaphore.release() 方法释放许可，以便其他线程可以获取连接。

“哇，这个 Semaphore 真是太方便了！有了它，再也不用担心数据库连接过多导致崩溃了！”

3. CountDownLatch：等待多个线程完成的“发令枪”

“还有别的工具吗？”

“当然有！接下来要介绍的这位，叫做 CountDownLatch，你可以把它想象成一个等待多个线程完成的‘发令枪’。”

CountDownLatch，中文名叫倒计时门闩，它可以让一个或多个线程等待其他线程完成操作后再继续执行。你可以把它想象成一场赛跑，多个运动员（线程）在起跑线等待，裁判员（CountDownLatch）拿着发令枪，当所有运动员都准备好后，裁判员扣动扳机，所有运动员同时起跑。

CountDownLatch 的主要方法有：

• countDown(): 将计数器减 1，当计数器减为 0 时，所有等待的线程都会被唤醒。
• await(): 让当前线程等待，直到计数器减为 0，或者线程被中断。

“这个 CountDownLatch 有什么用呢？”

“用处也很多！比如，你可以用 CountDownLatch 来实现并行计算，将一个大任务拆分成多个小任务，让多个线程并行执行，最后再将结果合并；你还可以用 CountDownLatch 来实现多线程协作，让多个线程协同完成一个任务，每个线程负责一部分工作，最后再将结果汇总。”

下面是一个使用 CountDownLatch 实现并行计算的例子：

import java.util.concurrent.CountDownLatch;

public class ParallelCalculator {

    private static final int NUM_THREADS = 4;
    private static final int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(NUM_THREADS);
        int chunkSize = numbers.length / NUM_THREADS;
        int[] results = new int[NUM_THREADS];

        // 创建多个线程，每个线程负责计算一部分数据的和
        for (int i = 0; i < NUM_THREADS; i++) {
            int startIndex = i * chunkSize;
            int endIndex = (i == NUM_THREADS - 1) ? numbers.length : (i + 1) * chunkSize;
            int threadIndex = i;
            new Thread(() -> {
                int sum = 0;
                for (int j = startIndex; j < endIndex; j++) {
                    sum += numbers[j];
                }
                results[threadIndex] = sum;
                System.out.println(Thread.currentThread().getName() + " 计算完成，结果为：" + sum);
                latch.countDown(); // 计数器减 1
            }).start();
        }

        latch.await(); // 等待所有线程完成

        // 将所有线程的计算结果合并
        int totalSum = 0;
        for (int result : results) {
            totalSum += result;
        }

        System.out.println("最终计算结果为：" + totalSum);
    }
}

在这个例子中，我们创建了一个 CountDownLatch，并设置了计数器为线程数量。每个线程计算完一部分数据的和之后，都会调用 latch.countDown() 方法将计数器减 1。主线程调用 latch.await() 方法等待所有线程完成，当计数器减为 0 时，主线程会被唤醒，然后将所有线程的计算结果合并，得到最终结果。

“原来 CountDownLatch 可以这么用！感觉并发编程越来越有趣了！”

4. CyclicBarrier：可重用的“栅栏”

“还有没有其他工具了？”

“当然有，不过在讲下一个工具之前，我先考考你。你觉得CountDownLatch 有什么不足之处？”

“CountDownLatch的不足之处...让我想想...好像CountDownLatch是一次性的，计数器减为0之后就不能再使用了？”

“没错！你的观察很敏锐！CountDownLatch 是一次性的，而接下来要介绍的 CyclicBarrier 则是可重用的。”

CyclicBarrier，中文名叫循环栅栏，它也可以让一组线程互相等待，直到所有线程都到达一个同步点，然后所有线程才能继续执行。CyclicBarrier 与 CountDownLatch 的区别在于，CyclicBarrier 的计数器可以重置，也就是说 CyclicBarrier 可以重复使用。

CyclicBarrier 的主要方法有：

• await(): 让当前线程等待，直到所有线程都到达同步点，或者线程被中断。
• reset(): 重置计数器，将 CyclicBarrier 恢复到初始状态。

“CyclicBarrier 听起来和 CountDownLatch 很像，它们有什么区别呢？”

“它们的主要区别在于：

• CountDownLatch 是一次性的，CyclicBarrier 是可重用的。
• CountDownLatch 的计数器只能减，CyclicBarrier 的计数器可以加也可以减。
• CountDownLatch 主要用于一个或多个线程等待其他线程完成操作，CyclicBarrier 主要用于一组线程互相等待。

CyclicBarrier 适用于多个线程分阶段完成任务的场景，每个阶段都需要所有线程都到达同步点后才能继续执行下一个阶段。例如，你可以用 CyclicBarrier 来实现多线程模拟游戏场景，每个线程模拟一个角色，每个阶段模拟一个场景，所有角色都完成当前场景的动作后，才能进入下一个场景。”

下面是一个使用 CyclicBarrier 实现多线程模拟游戏场景的例子：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class GameSimulation {

    private static final int NUM_PLAYERS = 3;
    private static final int NUM_STAGES = 3;
    private static final CyclicBarrier barrier = new CyclicBarrier(NUM_PLAYERS, () -> {
        System.out.println("所有玩家都已到达同步点，进入下一阶段！");
    });

    public static void main(String[] args) {
        // 创建多个线程，每个线程模拟一个玩家
        for (int i = 0; i < NUM_PLAYERS; i++) {
            new Thread(() -> {
                for (int stage = 1; stage <= NUM_STAGES; stage++) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " 正在执行阶段 " + stage + " 的任务...");
                        Thread.sleep((long) (Math.random() * 1000)); // 模拟任务耗时
                        System.out.println(Thread.currentThread().getName() + " 完成阶段 " + stage + " 的任务，等待其他玩家...");
                        barrier.await(); // 等待其他玩家
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

在这个例子中，我们创建了一个 CyclicBarrier，并设置了参与线程的数量为玩家数量。每个玩家线程在完成每个阶段的任务后，都会调用 barrier.await() 方法等待其他玩家。当所有玩家都到达同步点后，CyclicBarrier 的回调函数会被执行，打印一条消息，然后所有玩家线程继续执行下一个阶段的任务。CyclicBarrier 会自动重置计数器，因此可以循环使用。

“CyclicBarrier 真是太神奇了！有了它，就可以轻松实现多线程协作了！”

5. 总结：并发编程，不止于锁

“今天给你介绍了这么多并发编程的工具，你有什么感受？”

“太震撼了！原来 Java 并发编程的世界这么丰富多彩！以前我只知道用锁，现在才知道还有这么多‘神器’级别的工具，真是大开眼界！”

“哈哈，没错！Java 并发编程远不止于锁，Semaphore、CountDownLatch、CyclicBarrier 等工具都各有特点，适用于不同的场景。掌握这些工具，可以让你在处理并发问题时更加游刃有余，写出更高效、更健壮的程序。”

“不过，并发编程也不是一件容易的事情，除了掌握这些工具，还需要深入理解并发编程的原理，才能避免各种坑。比如，死锁、活锁、饥饿等问题，都是并发编程中常见的挑战。”

“我会继续努力学习的！争取早日成为并发编程高手！”

“加油！相信你一定可以的！记住，实践出真知，多写代码，多思考，多总结，你一定能在并发编程的世界里闯出一片天地！”

最后，再给你总结一下今天讲到的几个工具：

希望这篇文章能帮助你更好地理解 Java 并发编程中的这些“神器”工具！如果你还有其他问题，欢迎随时向我提问！