1

zj

2024-10-21 3a4ca606fad5d286e8b0de99f39ffbea8ef3cc21

 websocketSerivce/src/main/java/org/example/websocket/server/WsServer.java

@@ -176,9 +176,9 @@
//        // 等待所有任务执行完成
//        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
//    }

    public void sendMessageToAll(String message) {
        List<CompletableFuture<Void>> futures = new ArrayList<>();
        List<Future<Void>> futures = new ArrayList<>();
        ExecutorService executorService = Executors.newFixedThreadPool(100); // 使用固定大小的线程池

        // 收集所有活动的会话
        List<Session> activeSessions = new ArrayList<>();
@@ -193,33 +193,66 @@
        });

        // 并发处理所有活动的会话
        activeSessions.forEach(session -> {
            futures.add(CompletableFuture.runAsync(() -> {
        for (Session session : activeSessions) {
            Future<Void> future = executorService.submit(() -> {
                Lock sessionLock = getSessionLock(session.getId());
                sessionLock.lock();
                try {
                    if (sessionLock.tryLock(100, TimeUnit.MILLISECONDS)) {
                try {
                    schedulePushMessage(session, message);
                } catch (Exception e) {
                    log.error("发送消息时出现异常: {}", e.getMessage());
                    closeSession(session, "发送消息异常，断开链接");
                } finally {
                    sessionLock.unlock();
                            sessionLock.unlock(); // 确保锁只在这里释放
                }
            }, threadPoolTaskExecutor));
                    } else {
                        log.error("无法获取锁，放弃对会话 {} 的操作", session.getId());
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 重新设置中断状态
                    log.error("线程被中断: {}", e.getMessage());
                } catch (JsonProcessingException e) {
                    log.error("JSON处理异常: {}", e.getMessage());
                }
                return null; // 需要返回一个值，Void 类型的
        });

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        try {
            allFutures.join(); // 等待所有任务完成
        } finally {
            futures.clear(); // 清理未使用的 futures 列表
            futures.add(future);
        }

        // 等待所有任务完成或超时
        for (Future<Void> future : futures) {
            try {
                future.get(60, TimeUnit.SECONDS); // 指定超时时间
            } catch (TimeoutException e) {
                log.error("某个任务超时，可能未能完成: {}", e.getMessage());
                // 这里可以选择是否取消该任务
                future.cancel(true); // 取消任务，设置为 true 则会中断正在执行的线程
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
                log.error("线程被中断: {}", e.getMessage());
            } catch (ExecutionException e) {
                log.error("处理会话时发生异常: {}", e.getCause().getMessage());
            }
        }

        // 关闭线程池
        executorService.shutdown();
    }


    @PreDestroy
    public void shutdownExecutor() {
        threadPoolTaskExecutor.shutdown();
        threadPoolTaskExecutor.shutdown(); // 先关闭线程池
        try {
            // 等待现有任务在指定时间内完成
            if (!threadPoolTaskExecutor.getThreadPoolExecutor().awaitTermination(60, TimeUnit.SECONDS)) {
                // 如果未能完成，则强制关闭
                threadPoolTaskExecutor.getThreadPoolExecutor().shutdownNow();
            }
        } catch (InterruptedException e) {
            // 如果当前线程被中断，则强制关闭
            threadPoolTaskExecutor.getThreadPoolExecutor().shutdownNow();
            Thread.currentThread().interrupt(); // 还原中断状态
        }
    }

    private WsBo getWsBoForSession(String sessionId) {