Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Lorsqu'une machine se déconnecte, elle est confrontée à de nombreux problèmes : Comment la mettre hors ligne depuis le centre d'enregistrement ? Comment nettoyer et libérer les ressources ? Le client utilise également le cache local lors de l'extraction de la liste de services. Comment mettre à jour le cache local à temps ?

L'arrêt progressif de la machine serveur nécessite l'utilisation de ShutdownHook, ce qui équivaut à l'ajout d'un hook d'arrêt. Ce hook est un thread qui est appelé lorsque la JVM est arrêtée (c'est-à-dire lorsque le programme se termine) pour nettoyer les ressources et. s'arrêter gracieusement.

   public void clearAll() {
        log.info("addShutdownHook for clearAll");
        // 添加了一个关闭钩子，这个钩子是一个线程，它在JVM关闭时（即程序结束时）被调用，清理资源，优雅下机
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                InetSocketAddress inetSocketAddress = new InetSocketAddress(InetAddress.getLocalHost().getHostAddress(), NettyRpcServer.PORT);
                CuratorUtils.clearRegistry(CuratorUtils.getZkClient(), inetSocketAddress);
            } catch (UnknownHostException ignored) {
            }
            // 操作完整、优雅，便于释放连接资源，便于自定义清理逻辑
            ThreadPoolFactoryUtil.shutDownAllThreadPool();
        }));
    }

Dans le thread de hook, vous devez écrire la logique pour supprimer les nœuds du centre d'enregistrement, comme indiqué ci-dessous :

  // RPC Server端 本机所注册服务的缓存
  private static final Set<String> REGISTERED_PATH_SET = ConcurrentHashMap.newKeySet();
 
  public static void clearRegistry(CuratorFramework zkClient, InetSocketAddress inetSocketAddress) {
        REGISTERED_PATH_SET.stream().parallel().forEach(p -> {
            try {
                // 是本机在ZK注册的节点
                if (p.endsWith(inetSocketAddress.toString())) {
                    // 根据路径名删除节点
                    zkClient.delete().forPath(p);
                }
            } catch (Exception e) {
                log.error("clear registry for path [{}] fail", p);
            }
        });
        log.info("All registered services on the server are cleared:[{}]", REGISTERED_PATH_SET.toString());
    }

Après avoir supprimé le nœud dans le centre d'enregistrement ZK, les ressources du pool de threads doivent être libérées :

  public static void shutDownAllThreadPool() {
        log.info("call shutDownAllThreadPool method");
        THREAD_POOLS.entrySet().parallelStream().forEach(entry -> {
            ExecutorService executorService = entry.getValue();
            // 停止接收新的任务，但已提交的任务会继续执行
            executorService.shutdown();
            log.info("shut down thread pool [{}] [{}]", entry.getKey(), executorService.isTerminated());
            try {
                // 等待线程池中的任务在指定的时间内完成。如果在指定时间内线程池未能终止，会抛出 InterruptedException
                executorService.awaitTermination(10, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.error("Thread pool never terminated");
                // 指定时间内线程池未能终止，立即停止所有正在执行的任务
                executorService.shutdownNow();
            }
        });
    }

La personnalisation de la logique de fermeture du pool de threads peut réaliser la libération des ressources du pool de threads de manière plus élégante. Il peut cesser d'accepter de nouvelles tâches et continuer à exécuter les tâches soumises dans un certain délai d'attente. Si le temps d'attente est dépassé, le pool de threads est arrêté de force.