Java并发编程：构建部门级线程安全的排队取号系统

private DailyTurns callTurnLocal(int userId) {
    try {
        DailyTurns turn = null;
        // 1. 从数据库获取下一个可用号码
        turn = getNextTurnForUser(userId); // 假设这里也需要部门ID

        if (turn != null) {
            // 2. 更新号码状态为“已叫号”，并分配给用户
            turn.setTurnStatusId(TURN_STATUS_CALLED);
            turn.setEventDate(new Date());
            turn.setUserId(userId);

            // 3. 保存更新到数据库
            turn = save(turn);
        }
        return turn;
    } catch (Exception e) {
        // 异常处理
        return null;
    }
}

import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// 模拟排队号码实体
class DailyTurns {
    private int turnId;
    private int departmentId;
    private int userId;
    private int turnStatusId;
    private Date eventDate;

    public DailyTurns(int turnId, int departmentId) {
        this.turnId = turnId;
        this.departmentId = departmentId;
    }

    // Getters and Setters (省略部分代码，实际应用中需完整)
    public int getTurnId() { return turnId; }
    public void setTurnId(int turnId) { this.turnId = turnId; }
    public int getDepartmentId() { return departmentId; }
    public void setDepartmentId(int departmentId) { this.departmentId = departmentId; }
    public int getUserId() { return userId; }
    public void setUserId(int userId) { this.userId = userId; }
    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; }

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

// 模拟号码状态常量
class TurnStatus {
    public static final int TURN_STATUS_PENDING = 1; // 待叫号
    public static final int TURN_STATUS_CALLED = 2;  // 已叫号
    // ... 其他状态
}

public class TurnService {
    private static final Logger logger = LoggerFactory.getLogger(TurnService.class);

    // 使用ConcurrentHashMap存储每个部门的锁对象
    // 键是部门ID，值是用于同步的任意Object实例
    private final ConcurrentHashMap<Integer, Object> departmentLocks = new ConcurrentHashMap<>();

    // 模拟从数据库获取下一个可用号码
    // **重要提示：此方法内部仍需数据库层面的并发控制，详见下文**
    private DailyTurns getNextTurnForDepartment(int departmentId) {
        // 模拟数据库查询耗时
        try {
            Thread.sleep((long) (Math.random() * 50)); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.warn("Thread interrupted while simulating DB latency.", e);
        }

        // 实际场景中，这里会查询数据库，获取该部门下一个未被叫号的号码
        // 并可能需要使用 SELECT ... FOR UPDATE 等数据库锁机制来预留号码
        // 这里简化为生成一个模拟的号码
        int nextTurnId = generateNextDummyTurnId(departmentId); // 模拟生成一个号码
        if (nextTurnId > 0) {
            return new DailyTurns(nextTurnId, departmentId);
        }
        return null;
    }

    // 模拟生成下一个号码ID（非线程安全，仅用于演示应用层逻辑）
    private static final ConcurrentHashMap<Integer, Integer> departmentTurnCounters = new ConcurrentHashMap<>();
    private int generateNextDummyTurnId(int departmentId) {
        return departmentTurnCounters.compute(departmentId, (k, v) -> (v == null ? 1 : v + 1));
    }

    // 模拟将更新后的号码信息保存到数据库
    private DailyTurns save(DailyTurns turn) {
        // 实际中会将更新后的DailyTurns对象保存到数据库
        logger.info("保存叫号信息： " + turn);
        return turn;
    }

    /**
     * 为指定用户和部门获取下一个号码。
     * 该方法实现了部门级的线程安全。
     *
     * @param userId 用户ID
     * @param departmentId 部门ID
     * @return 获取到的号码信息，如果失败则返回null
     */
    public DailyTurns callTurnLocal(int userId, int departmentId) {
        DailyTurns resultTurn = null;

        // 获取或创建该部门的锁对象。
        // computeIfAbsent 是线程安全的，确保每个 departmentId 只有一个锁对象被创建。
        // 如果 departmentId 对应的锁不存在，则会创建一个新的 Object 实例作为锁。
        Object departmentLock = departmentLocks.computeIfAbsent(departmentId, k -> new Object());

        // 对该部门的锁对象进行同步
        synchronized (departmentLock) {
            try {
                DailyTurns fetchedTurn = null;

                // 1. 获取下一个号码。
                // 这一步在应用层已经由 departmentLock 保证了同一部门的串行访问。
                // 但仍需注意数据库层面的并发控制。
                fetchedTurn = getNextTurnForDepartment(departmentId);

                if (fetchedTurn != null) {
                    resultTurn = fetchedTurn;

                    // 2. 更新号码状态和用户信息
                    resultTurn.setTurnStatusId(TurnStatus.TURN_STATUS_CALLED);
                    resultTurn.setEventDate(new Date());
                    resultTurn.setUserId(userId);

                    // 3. 保存更新到数据库
                    resultTurn = save(resultTurn);
                }

                return resultTurn;
            } catch (Exception e) {
                logger.error("为部门 " + departmentId + " 取号时发生异常: " + e.getMessage(), e);
                return null;
            }
        }
    }

    // 示例主方法，模拟多线程并发取号
    public static void main(String[] args) throws InterruptedException {
        TurnService service = new TurnService();
        // 模拟15个用户，分别来自部门1、2、3
        for (int i = 0; i < 15; i++) {
            final int user = i + 1;
            final int dept = (i % 3) + 1; // 部门ID在1, 2, 3之间循环
            new Thread(() -> {
                DailyTurns turn = service.callTurnLocal(user, dept);
                if (turn != null) {
                    System.out.println("用户 " + user + " (部门 " + dept + ") 成功获取号码: " + turn.getTurnId());
                } else {
                    System.out.println("用户 " + user + " (部门 " + dept + ") 未能获取号码。");
                }
            }).start();
        }
        // 等待所有线程完成，以便观察输出
        Thread.sleep(2000); 
    }
}