Java多部门叫号系统：基于部门的并发控制与线程安全实现

心靈之曲

发布时间：2025-11-20 17:40:09

857人浏览过

来源于php中文网

原创

java多部门叫号系统：基于部门的并发控制与线程安全实现

本文探讨了在多部门叫号系统中，如何高效且安全地为用户分配叫号。针对同一部门用户并发请求可能导致的叫号重复问题，以及全局锁在多部门场景下的性能瓶颈，文章提出并详细阐述了基于`ConcurrentHashMap`实现部门级精细化同步的解决方案。通过此方法，可确保同一部门内的叫号操作线程安全，同时允许不同部门间的操作并行进行，从而优化系统性能和用户体验。

引言：并发叫号系统的挑战

在需要为用户分配顺序叫号的系统中，尤其是在多部门环境下，实现线程安全和高并发是一项关键挑战。当多个用户几乎同时请求“下一个叫号”时，如果处理不当，可能会出现竞态条件，导致多个用户获取到相同的叫号，从而破坏系统的公平性和唯一性。

一个典型的叫号分配流程通常包括以下步骤：

查询数据库获取当前部门的下一个可用叫号。
标记该叫号为已分配（例如，更新状态、记录分配时间、关联用户ID）。
将更新后的叫号信息保存回数据库。

如果上述操作不是原子性的，即便是单线程操作，在多线程环境下也可能因为上下文切换而出现问题。更复杂的是，如果系统支持多个部门，并且希望不同部门的用户可以同时请求叫号，而同一部门的用户必须串行获取叫号，那么传统的全局同步机制将无法满足性能需求。

立即学习“Java免费学习笔记（深入）”；

传统同步机制的局限性

最直观的解决竞态条件的方法是使用同步锁，例如在Java中对整个叫号分配方法使用synchronized关键字。

public synchronized DailyTurns callTurnLocal(int userId) {
    // ... 获取并更新叫号的逻辑 ...
}

这种全局同步机制虽然能确保任何时刻只有一个线程能执行callTurnLocal方法，从而避免了叫号重复的问题，但它也带来了严重的性能瓶颈。如果系统中有多个部门，并且来自不同部门的用户同时请求叫号，全局锁会强制这些请求串行执行。这意味着，即使部门A和部门B的叫号系统是完全独立的，它们也必须等待彼此的操作完成，这显然降低了系统的并发处理能力。

为了更好地理解原始逻辑，以下是其简化伪代码：

private DailyTurns callTurnLocal(int userId) {
    try {
        DailyTurns turn = null;
        DailyTurns updateTurn = null;

        // 1. 从数据库获取下一个可用叫号
        turn = getNextTurnForUser(userId); // 假设此方法也需要 departmentId

        if (turn != null) {
            updateTurn = turn;
            // 2. 更新叫号状态和信息
            updateTurn.setTurnStatusId(TURN_STATUS_CALLED);
            updateTurn.setEventDate(new Date());
            updateTurn.setUserId(userId);

            // 3. 保存更新后的叫号信息到数据库
            updateTurn = save(updateTurn);
        }
        return updateTurn;
    } catch (Exception e) {
        // 错误处理
        return null;
    }
}

在这个基础上，我们需要一种更精细的同步策略，既能保证同一部门内的操作原子性，又能允许不同部门间的操作并行。

基于部门的精细化同步策略

为了实现部门级别的并发控制，我们可以为每个部门维护一个独立的锁对象。当一个线程需要为某个部门获取叫号时，它会尝试获取该部门对应的锁。这样，来自同一部门的所有请求将共享同一个锁，从而串行执行；而来自不同部门的请求将获取不同的锁，允许它们并行执行。

使用 ConcurrentHashMap 实现部门级锁

Java的ConcurrentHashMap是一个非常适合用于管理部门级锁的工具。我们可以使用部门ID作为键，将部门对应的锁对象作为值存储在ConcurrentHashMap中。

核心思想：

PHP 网络编程技术与实例(曹衍龙)

PHP网络编程技术详解由浅入深，全面、系统地介绍了PHP开发技术，并提供了大量实例，供读者实战演练。另外，笔者专门为本书录制了相应的配套教学视频，以帮助读者更好地学习本书内容。这些视频和书中的实例源代码一起收录于配书光盘中。本书共分4篇。第1篇是PHP准备篇，介绍了PHP的优势、开发环境及安装；第2篇是PHP基础篇，介绍了PHP中的常量与变量、运算符与表达式、流程控制以及函数；第3篇是进阶篇，介绍

下载

创建一个ConcurrentHashMap，其中Integer代表部门ID，Object是用于同步的锁对象。
当需要为某个部门获取叫号时，首先通过部门ID从ConcurrentHashMap中获取或创建对应的锁对象。
然后，对这个部门专属的锁对象进行同步操作。

以下是实现这一策略的示例代码：

import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;

public class DailyTurnService {

    // 用于存储每个部门的锁对象
    private final ConcurrentHashMap departmentLocks = new ConcurrentHashMap<>();
    private static final int TURN_STATUS_CALLED = 1; // 假设叫号已分配状态ID

    // 模拟日志记录器
    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(DailyTurnService.class);

    // 模拟数据库操作：获取下一个可用叫号
    private DailyTurns getNextTurnForUser(int userId, int departmentId) {
        // 实际场景中会查询数据库，这里简化为模拟返回一个DailyTurns对象
        // 假设数据库中有一个自增的叫号序列
        System.out.println(Thread.currentThread().getName() + " - 部门" + departmentId + ": 正在获取下一个叫号...");
        try {
            Thread.sleep(100); // 模拟数据库查询耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 模拟从数据库获取一个叫号
        // 在实际数据库中，需要使用 SELECT ... FOR UPDATE 等机制确保原子性
        DailyTurns turn = new DailyTurns();
        turn.setTurnId(System.currentTimeMillis() % 100000); // 简化生成一个ID
        turn.setDepartmentId(departmentId);
        turn.setTurnStatusId(0); // 初始状态
        System.out.println(Thread.currentThread().getName() + " - 部门" + departmentId + ": 获取到叫号 " + turn.getTurnId());
        return turn;
    }

    // 模拟数据库操作：保存叫号信息
    private DailyTurns save(DailyTurns turn) {
        System.out.println(Thread.currentThread().getName() + " - 部门" + turn.getDepartmentId() + ": 正在保存叫号 " + turn.getTurnId() + " 的更新...");
        try {
            Thread.sleep(50); // 模拟数据库更新耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println(Thread.currentThread().getName() + " - 部门" + turn.getDepartmentId() + ": 叫号 " + turn.getTurnId() + " 保存成功.");
        return turn;
    }

    /**
     * 为指定用户和部门获取下一个叫号，并确保部门内线程安全。
     *
     * @param userId       用户ID
     * @param departmentId 部门ID
     * @return 分配到的叫号信息，如果失败则返回null
     */
    public DailyTurns callTurnLocal(int userId, int departmentId) {
        // 获取或创建部门专属的锁对象
        // computeIfAbsent 确保如果部门ID不存在，则创建一个新的Object作为锁并放入Map
        // 如果已存在，则返回已有的锁对象
        Object departmentLock = departmentLocks.computeIfAbsent(departmentId, k -> new Object());

        // 对部门专属的锁对象进行同步
        synchronized (departmentLock) {
            System.out.println(Thread.currentThread().getName() + " - 部门" + departmentId + ": 进入同步块，准备处理叫号...");
            DailyTurns updateTurn = null;
            try {
                DailyTurns turn = null;

                // 1. 获取下一个可用叫号 (可能需要部门ID作为参数)
                turn = getNextTurnForUser(userId, departmentId);

                if (turn != null) {
                    updateTurn = turn;

                    // 2. 更新叫号状态和信息
                    updateTurn.setTurnStatusId(TURN_STATUS_CALLED);
                    updateTurn.setEventDate(new Date());
                    updateTurn.setUserId(userId);

                    // 3. 保存更新后的叫号信息到数据库
                    updateTurn = save(updateTurn);
                }
                System.out.println(Thread.currentThread().getName() + " - 部门" + departmentId + ": 成功处理叫号 " + (updateTurn != null ? updateTurn.getTurnId() : "N/A"));
                return updateTurn;
            } catch (Exception e) {
                logger.error("Exception in callTurnLocal for department " + departmentId + ": " + e.getMessage(), e);
                return null;
            } finally {
                System.out.println(Thread.currentThread().getName() + " - 部门" + departmentId + ": 退出同步块.");
            }
        }
    }

    // 模拟DailyTurns实体类
    static class DailyTurns {
        private long turnId;
        private int departmentId;
        private int turnStatusId;
        private Date eventDate;
        private int userId;

        public long getTurnId() { return turnId; }
        public void setTurnId(long turnId) { this.turnId = turnId; }
        public int getDepartmentId() { return departmentId; }
        public void setDepartmentId(int departmentId) { this.departmentId = departmentId; }
        public int getTurnStatusId() { return turnStatusId; }
        public void setTurnStatusId(int turnStatusId) { this.turnStatusId = turnStatusId; }
        public Date getEventDate() { return eventDate; }
        public void setEventDate(Date eventDate) { this.eventDate = eventDate; }
        public int getUserId() { return userId; }
        public void setUserId(int userId) { this.userId = userId; }

        @Override
        public String toString() {
            return "DailyTurns{" +
                   "turnId=" + turnId +
                   ", departmentId=" + departmentId +
                   ", turnStatusId=" + turnStatusId +
                   ", eventDate=" + eventDate +
                   ", userId=" + userId +
                   '}';
        }
    }

    // 简单的测试用例
    public static void main(String[] args) {
        DailyTurnService service = new DailyTurnService();

        // 模拟来自不同部门和同一部门的并发请求
        Runnable task1 = () -> service.callTurnLocal(101, 1); // 用户101，部门1
        Runnable task2 = () -> service.callTurnLocal(102, 1); // 用户102，部门1 (与task1竞争)
        Runnable task3 = () -> service.callTurnLocal(201, 2); // 用户201，部门2 (与task1/task2不竞争)
        Runnable task4 = () -> service.callTurnLocal(103, 1); // 用户103，部门1 (与task1/task2竞争)
        Runnable task5 = () -> service.callTurnLocal(202, 2); // 用户202，部门2 (与task3不竞争)

        new Thread(task1, "Thread-Dept1-User1").start();
        new Thread(task2, "Thread-Dept1-User2").start();
        new Thread(task3, "Thread-Dept2-User1").start();
        new Thread(task4, "Thread-Dept1-User3").start();
        new Thread(task5, "Thread-Dept2-User2").start();
    }
}

在上述示例中：

departmentLocks ConcurrentHashMap 存储了每个部门ID对应的锁对象。
departmentLocks.computeIfAbsent(departmentId, k -> new Object()) 是获取部门锁的关键。它会原子性地检查departmentId是否已存在于Map中：
- 如果存在，则返回对应的锁对象。
- 如果不存在，则创建一个新的Object实例作为锁，将其与departmentId关联并放入Map，然后返回这个新创建的锁对象。
- 这种方式确保了每个部门ID始终对应唯一的锁对象，并且创建过程是线程安全的。
synchronized (departmentLock) 语句块确保了对于同一个departmentId，任何时刻只有一个线程能够执行其内部的代码，从而避免了同一部门内的竞态条件。
不同departmentId的线程将获取不同的departmentLock对象，因此它们可以并行执行，互不影响。

数据库层面的考量

尽管应用程序层面的ConcurrentHashMap锁解决了同一应用实例内不同线程的同步问题，但在分布式部署（即多个应用服务器实例同时运行）或直接通过其他客户端访问数据库的场景下，仅靠应用层锁是不够的。此时，还需要依赖数据库本身的事务隔离和锁定机制来确保数据的一致性和原子性。

常见的数据库锁定策略包括：

悲观锁： 使用SELECT ... FOR UPDATE语句。在查询下一个可用叫号时，立即锁定该记录或相关表，直到事务提交。这能有效防止其他并发事务读取或修改同一记录。例如：
```
SELECT * FROM daily_turns WHERE department_id = ? AND status = 'available' ORDER BY turn_number ASC LIMIT 1 FOR UPDATE;
```
然后应用程序获取该叫号，更新其状态，并提交事务。
乐观锁： 在叫号表中添加一个版本号（version）或时间戳字段。更新叫号时，检查版本号是否与查询时一致，如果不一致则表示其他事务已修改，需要重试。
```
UPDATE daily_turns SET status = 'called', user_id = ?, version = version + 1 WHERE turn_id = ? AND version = ?;
```
如果更新影响的行数为0，则表示更新失败，需要重新获取叫号。

结合数据库层面的锁定机制，可以构建一个更加健壮和可靠的叫号系统。通常，推荐在应用程序层使用精细化锁（如本文介绍的ConcurrentHashMap方式）来减少数据库的并发压力，同时在数据库事务中利用FOR UPDATE等语句作为最终的数据一致性保障。

总结与最佳实践

在设计多部门叫号系统时，实现高效的并发控制至关重要。本文提出的基于ConcurrentHashMap的部门级同步策略，通过为每个部门分配独立的锁对象，有效地解决了同一部门内的叫号重复问题，同时避免了全局锁带来的性能瓶颈，允许不同部门的请求并行处理。

关键 takeaways：

细粒度锁： 避免使用粗粒度的全局锁，应根据业务逻辑划分同步范围，使用细粒度锁提升并发性能。
ConcurrentHashMap的妙用： 利用其线程安全的特性，动态管理和获取与业务实体（如部门ID）关联的锁对象。
computeIfAbsent： 这是获取或创建锁对象的推荐方式，它确保了原子性操作和资源的高效利用。
数据库事务与锁： 在分布式或高并发场景下，应用程序层面的锁并非万能，数据库层面的事务隔离和锁定（如SELECT ... FOR UPDATE）是保证数据最终一致性和原子性的重要手段。

通过综合运用这些技术，可以构建一个既能保证数据一致性和线程安全，又能满足高并发性能需求的多部门叫号系统。

Java对象池与内存管理优化技巧

Java里Future的作用是什么_Java异步结果获取机制说明

Java自学的网站_Java从入门到精通的自学平台

Java里负载因子对HashMap性能的影响_Java哈希冲突说明

Java初学者项目实战：开发简单的待办事项清单