Condivisione della tecnologia

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

Quando una macchina va offline, deve affrontare molti problemi: come portarla offline dal centro di registrazione? Come ripulire e rilasciare risorse? Il client utilizza anche la cache locale quando estrae l'elenco dei servizi. Come aggiornare tempestivamente la cache locale?

L'arresto regolare della macchina server richiede l'uso di ShutdownHook, che equivale ad aggiungere un hook di arresto. Questo hook è un thread che viene chiamato quando la JVM viene arrestata (ovvero quando il programma termina) per pulire le risorse e. spegnersi con grazia.

   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();
        }));
    }

Nel thread di hook è necessario scrivere la logica per eliminare i nodi dal centro di registrazione, come mostrato di seguito:

  // 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());
    }

Dopo aver eliminato il nodo nel centro di registrazione ZK, è necessario rilasciare le risorse del pool di thread:

  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 personalizzazione della logica di chiusura del pool di thread può realizzare il rilascio delle risorse del pool di thread in modo più elegante. È possibile interrompere l'accettazione di nuove attività e continuare a eseguire le attività inviate entro un determinato tempo di attesa. Se il tempo di attesa viene superato, il pool di thread viene terminato forzatamente.