#9708

pending completion

Build # #9708

Build Type

push

travis_ci

Committed by

web-flow

Commit Message

[To rel/1.2] Enhance warning messages for ConfigNodeClient (#10722)

Signed-off-by: OneSizeFitQuorum <tanxinyu@apache.org>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

79235 of 165170 relevant lines covered (47.97%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.43

/iotdb-core/node-commons/src/main/java/org/apache/iotdb/commons/concurrent/ThreadName.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.iotdb.commons.concurrent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Pattern;

public enum ThreadName {
  // -------------------------- QueryThread --------------------------
  QUERY_WORKER("Query-Worker-Thread"),
  QUERY_SENTINEL("Query-Sentinel-Thread"),
  TIMED_QUERY_SQL_COUNT("Timed-Query-SQL-Count"),
  FRAGMENT_INSTANCE_MANAGEMENT("Fragment-Instance-Management"),
  FRAGMENT_INSTANCE_NOTIFICATION("Fragment-Instance-Notification"),
  DRIVER_TASK_SCHEDULER_NOTIFICATION("Driver-Task-Scheduler-Notification"),
  // -------------------------- MPP --------------------------
  MPP_COORDINATOR_SCHEDULED_EXECUTOR("MPP-Coordinator-Scheduled-Executor"),
  MPP_DATA_EXCHANGE_TASK_EXECUTOR("MPP-Data-Exchange-Task-Executors"),
  ASYNC_DATANODE_CLIENT_POOL("AsyncDataNodeInternalServiceClientPool"),
  MPP_DATA_EXCHANGE_RPC_SERVICE("MPPDataExchangeRPC-Service"),
  MPP_DATA_EXCHANGE_RPC_PROCESSOR("MPPDataExchangeRPC-Processor"),
  MPP_COORDINATOR_EXECUTOR_POOL("MPP-Coordinator-Executor"),
  DATANODE_INTERNAL_RPC_SERVICE("DataNodeInternalRPC-Service"),
  DATANODE_INTERNAL_RPC_PROCESSOR("DataNodeInternalRPC-Processor"),
  MPP_COORDINATOR_WRITE_EXECUTOR("MPP-Coordinator-Write-Executor"),
  ASYNC_DATANODE_MPP_DATA_EXCHANGE_CLIENT_POOL("AsyncDataNodeMPPDataExchangeServiceClientPool"),

  // -------------------------- Compaction --------------------------
  COMPACTION_WORKER("Compaction-Worker"),
  COMPACTION_SUB_TASK("Compaction-Sub-Task"),
  COMPACTION_SCHEDULE("Compaction-Schedule"),
  // -------------------------- Wal --------------------------
  WAL_SERIALIZE("WAL-Serialize"),
  WAL_SYNC("WAL-Sync"),
  WAL_DELETE("WAL-Delete"),
  WAL_RECOVER("WAL-Recover"),
  TSFILE_RECOVER("TsFile-Recover"),
  // -------------------------- Flush --------------------------
  FLUSH("Flush"),
  FLUSH_SUB_TASK("Flush-SubTask"),
  FLUSH_TASK_SUBMIT("FlushTask-Submit-Pool"),
  TIMED_FLUSH_SEQ_MEMTABLE("Timed-Flush-Seq-Memtable"),
  TIMED_FLUSH_UNSEQ_MEMTABLE("Timed-Flush-Unseq-Memtable"),
  // -------------------------- SchemaEngine --------------------------
  SCHEMA_REGION_RELEASE_PROCESSOR("SchemaRegion-Release-Task-Processor"),
  SCHEMA_REGION_RECOVER_TASK("SchemaRegion-recover-task"),
  SCHEMA_RELEASE_MONITOR("Schema-Release-Task-Monitor"),
  SCHEMA_REGION_FLUSH_PROCESSOR("SchemaRegion-Flush-Task-Processor"),
  SCHEMA_FLUSH_MONITOR("Schema-Flush-Task-Monitor"),
  SCHEMA_FORCE_MLOG("SchemaEngine-TimedForceMLog-Thread"),
  // -------------------------- ClientService --------------------------
  CLIENT_RPC_SERVICE("ClientRPC-Service"),
  CLIENT_RPC_PROCESSOR("ClientRPC-Processor"),
  // -------------------------- ConfigNode-RPC --------------------------
  CONFIGNODE_RPC_SERVICE("ConfigNodeRPC-Service"),
  CONFIGNODE_RPC_PROCESSOR("ConfigNodeRPC-Processor"),
  ASYNC_CONFIGNODE_CLIENT_POOL("AsyncConfigNodeIServiceClientPool"),
  // -------------------------- ConfigNode-Query --------------------------
  CQ_SCHEDULER("CQ-Scheduler"),
  // -------------------------- ConfigNode-Write --------------------------
  CONFIG_NODE_SIMPLE_CONSENSUS_WAL_FLUSH("ConfigNode-Simple-Consensus-WAL-Flush-Thread"),
  // -------------------------- ConfigNode-Heartbeat --------------------------
  CONFIG_NODE_HEART_BEAT_SERVICE("Cluster-Heartbeat-Service"),
  ASYNC_CONFIGNODE_HEARTBEAT_CLIENT_POOL("AsyncConfigNodeHeartbeatServiceClientPool"),
  ASYNC_DATANODE_HEARTBEAT_CLIENT_POOL("AsyncDataNodeHeartbeatServiceClientPool"),
  // -------------------------- ConfigNode-LoadBalance --------------------------
  CONFIG_NODE_LOAD_STATISTIC("Cluster-LoadStatistics-Service"),
  // -------------------------- ConfigNode-RegionManagement --------------------------
  CONFIG_NODE_REGION_MAINTAINER("IoTDB-Region-Maintainer"),
  // -------------------------- ConfigNode-Recover --------------------------
  CONFIG_NODE_RECOVER("ConfigNode-Manager-Recovery"),
  // -------------------------- ConfigNode-Procedure ------------------------
  // TODO: Use Thread Pool to manage the procedure thread @Potato
  CONFIG_NODE_PROCEDURE_WORKER("ProcedureWorkerGroup"),
  CONFIG_NODE_TIMEOUT_EXECUTOR("ProcedureTimeoutExecutor"),
  CONFIG_NODE_WORKER_THREAD_MONITOR("ProcedureWorkerThreadMonitor"),
  CONFIG_NODE_RETRY_FAILED_TASK("Cluster-RetryFailedTasks-Service"),

  // -------------------------- IoTConsensus --------------------------
  IOT_CONSENSUS_RPC_SERVICE("IoTConsensusRPC-Service"),
  IOT_CONSENSUS_RPC_PROCESSOR("IoTConsensusRPC-Processor"),
  ASYNC_DATANODE_IOT_CONSENSUS_CLIENT_POOL("AsyncDataNodeIoTConsensusServiceClientPool"),
  LOG_DISPATCHER("LogDispatcher"),
  // -------------------------- Ratis --------------------------
  // NOTICE: The thread name of ratis cannot be edited here!
  // We list the thread name here just for distinguishing what module the thread belongs to.
  RAFT_SERVER_PROXY_EXECUTOR("\\d+-impl-thread"),
  RAFT_SERVER_EXECUTOR("\\d+-server-thread"),
  RAFT_SERVER_CLIENT_EXECUTOR("\\d+-client-thread"),
  RATIS_ADD("Ratis-Add"),
  SEGMENT_RAFT_WORKER("SegmentedRaftLogWorker"),
  STATE_MACHINE_UPDATER("StateMachineUpdater"),
  FOLLOWER_STATE("FollowerState"),
  LEADER_STATE_IMPL_PROCESSOR("LeaderStateImpl"),
  LEADER_ELECTION("LeaderElection"),
  LOG_APPENDER("GrpcLogAppender"),
  EVENT_PROCESSOR("EventProcessor"),
  RATIS_BG_DISK_GUARDIAN("RatisBgDiskGuardian"),
  GRPC_DEFAULT_BOSS_ELG("grpc-default-boss-ELG"),
  GRPC_DEFAULT_EXECUTOR("grpc-default-executor"),
  GPRC_DEFAULT_WORKER_ELG("grpc-default-worker-ELG"),
  GROUP_MANAGEMENT("groupManagement"),
  // -------------------------- Compute --------------------------
  PIPE_ASSIGNER_EXECUTOR_POOL("Pipe-Assigner-Executor-Pool"),
  PIPE_PROCESSOR_EXECUTOR_POOL("Pipe-Processor-Executor-Pool"),
  PIPE_CONNECTOR_EXECUTOR_POOL("Pipe-Connector-Executor-Pool"),
  PIPE_SUBTASK_CALLBACK_EXECUTOR_POOL("Pipe-SubTask-Callback-Executor-Pool"),
  PIPE_RUNTIME_META_SYNCER("Pipe-Runtime-Meta-Syncer"),
  PIPE_RUNTIME_HEARTBEAT("Pipe-Runtime-Heartbeat"),
  PIPE_RUNTIME_PROCEDURE_SUBMITTER("Pipe-Runtime-Procedure-Submitter"),
  PIPE_ASYNC_CONNECTOR_CLIENT_POOL("Pipe-Async-Connector-Client-Pool"),
  PIPE_ASYNC_CONNECTOR_RETRY_TRIGGER("Pipe-Async-Connector-Retry-Trigger"),
  PIPE_WAL_RESOURCE_TTL_CHECKER("Pipe-WAL-Resource-TTL-Checker"),
  WINDOW_EVALUATION_SERVICE("WindowEvaluationTaskPoolManager"),
  STATEFUL_TRIGGER_INFORMATION_UPDATER("Stateful-Trigger-Information-Updater"),
  // -------------------------- JVM --------------------------
  // NOTICE: The thread name of jvm cannot be edited here!
  // We list the thread name here just for distinguishing what module the thread belongs to.
  JVM_PAUSE_MONITOR("JvmPauseMonitor"),
  JVM_GC_STATISTICS_MONITOR("JVM-GC-Statistics-Monitor"),
  PARALLEL_GC("GC task thread"),
  G1_GC("GC Thread"),
  G1_MAIN_MARKER("G1 Main Marker"),
  G1_CONC("G1 Conc"),
  G1_REFINE("G1 Refine"),
  G1_YOUNG_REMSET_SAMPLING("G1 Young RemSet Sampling"),
  COMPILE("CompilerThread"),
  VM_PERIODIC_TASK("VM Periodic Task Thread"),
  VM_THREAD("VM Thread"),
  REFERENCE_HANDLER("Reference Handler"),
  FINALIZER("Finalizer"),
  SIGNAL_DISPATCHER("Signal Dispatcher"),
  DESTROY_JVM("DestroyJavaVM"),
  COMMON_CLEANER("Common-Cleaner"),
  // -------------------------- LogThread --------------------------
  LOG_BACK("logback"),
  // -------------------------- Metrics --------------------------
  SYSTEM_SCHEDULE_METRICS("SystemScheduleMetrics"),
  RESOURCE_CONTROL_DISK_STATISTIC("ResourceControl-DataRegionDiskStatistics"),
  PROMETHEUS_REACTOR_HTTP_EPOLL("reactor-http-epoll"),
  PROMETHEUS_REACTOR_HTTP_NIO("reactor-http-nio"),
  PROMETHEUS_BOUNDED_ELASTIC("boundedElastic-evictor"),
  // -------------------------- Other --------------------------
  TTL_CHECK("TTL-CHECK"),
  SETTLE("Settle"),
  INFLUXDB_RPC_SERVICE("InfluxdbRPC-Service"),
  INFLUXDB_RPC_PROCESSOR("InfluxdbRPC-Processor"),
  STORAGE_ENGINE_CACHED_POOL("StorageEngine"),
  MLNODE_RPC_SERVICE("MLNodeRpc-Service"),
  IOTDB_SHUTDOWN_HOOK("IoTDB-Shutdown-Hook"),
  UPGRADE_TASK("UpgradeThread"),
  REGION_MIGRATE("Region-Migrate-Pool"),
  STORAGE_ENGINE_RECOVER_TRIGGER("StorageEngine-RecoverTrigger"),
  // the unknown thread name is used for metrics
  UNKOWN("UNKNOWN");

  private final String name;
  private static final Logger log = LoggerFactory.getLogger(ThreadName.class);
  private static final Set<ThreadName> queryThreadNames =
      new HashSet<>(
          Arrays.asList(
              QUERY_WORKER,
              QUERY_SENTINEL,
              TIMED_QUERY_SQL_COUNT,
              FRAGMENT_INSTANCE_MANAGEMENT,
              FRAGMENT_INSTANCE_NOTIFICATION,
              DRIVER_TASK_SCHEDULER_NOTIFICATION));
  private static final Set<ThreadName> mppThreadNames =
      new HashSet<>(
          Arrays.asList(
              MPP_COORDINATOR_SCHEDULED_EXECUTOR,
              MPP_DATA_EXCHANGE_TASK_EXECUTOR,
              ASYNC_DATANODE_CLIENT_POOL,
              MPP_DATA_EXCHANGE_RPC_SERVICE,
              MPP_DATA_EXCHANGE_RPC_PROCESSOR,
              MPP_COORDINATOR_EXECUTOR_POOL,
              DATANODE_INTERNAL_RPC_SERVICE,
              DATANODE_INTERNAL_RPC_PROCESSOR,
              MPP_COORDINATOR_WRITE_EXECUTOR,
              ASYNC_DATANODE_MPP_DATA_EXCHANGE_CLIENT_POOL));
  private static final Set<ThreadName> compactionThreadNames =
      new HashSet<>(Arrays.asList(COMPACTION_WORKER, COMPACTION_SUB_TASK, COMPACTION_SCHEDULE));

  private static final Set<ThreadName> walThreadNames =
      new HashSet<>(
          Arrays.asList(WAL_SERIALIZE, WAL_SYNC, WAL_DELETE, WAL_RECOVER, TSFILE_RECOVER));

  private static final Set<ThreadName> flushThreadNames =
      new HashSet<>(
          Arrays.asList(
              FLUSH,
              FLUSH_SUB_TASK,
              FLUSH_TASK_SUBMIT,
              TIMED_FLUSH_SEQ_MEMTABLE,
              TIMED_FLUSH_UNSEQ_MEMTABLE));
  private static final Set<ThreadName> schemaEngineThreadNames =
      new HashSet<>(
          Arrays.asList(
              SCHEMA_REGION_RELEASE_PROCESSOR,
              SCHEMA_REGION_RECOVER_TASK,
              SCHEMA_RELEASE_MONITOR,
              SCHEMA_REGION_FLUSH_PROCESSOR,
              SCHEMA_FLUSH_MONITOR,
              SCHEMA_FORCE_MLOG));

  private static final Set<ThreadName> clientServiceThreadNames =
      new HashSet<>(Arrays.asList(CLIENT_RPC_SERVICE, CLIENT_RPC_PROCESSOR));

  private static final Set<ThreadName> iotConsensusThreadNames =
      new HashSet<>(
          Arrays.asList(
              IOT_CONSENSUS_RPC_SERVICE,
              IOT_CONSENSUS_RPC_PROCESSOR,
              ASYNC_DATANODE_IOT_CONSENSUS_CLIENT_POOL,
              LOG_DISPATCHER));

  private static final Set<ThreadName> ratisThreadNames =
      new HashSet<>(
          Arrays.asList(
              RAFT_SERVER_PROXY_EXECUTOR,
              RAFT_SERVER_EXECUTOR,
              RAFT_SERVER_CLIENT_EXECUTOR,
              RATIS_ADD,
              SEGMENT_RAFT_WORKER,
              STATE_MACHINE_UPDATER,
              FOLLOWER_STATE,
              LEADER_STATE_IMPL_PROCESSOR,
              LEADER_ELECTION,
              LOG_APPENDER,
              EVENT_PROCESSOR,
              RATIS_BG_DISK_GUARDIAN,
              GRPC_DEFAULT_BOSS_ELG,
              GPRC_DEFAULT_WORKER_ELG,
              GRPC_DEFAULT_EXECUTOR,
              GROUP_MANAGEMENT));
  private static final Set<ThreadName> computeThreadNames =
      new HashSet<>(
          Arrays.asList(
              PIPE_ASSIGNER_EXECUTOR_POOL,
              PIPE_PROCESSOR_EXECUTOR_POOL,
              PIPE_CONNECTOR_EXECUTOR_POOL,
              PIPE_SUBTASK_CALLBACK_EXECUTOR_POOL,
              PIPE_RUNTIME_META_SYNCER,
              PIPE_RUNTIME_HEARTBEAT,
              PIPE_RUNTIME_PROCEDURE_SUBMITTER,
              PIPE_ASYNC_CONNECTOR_CLIENT_POOL,
              PIPE_ASYNC_CONNECTOR_RETRY_TRIGGER,
              PIPE_WAL_RESOURCE_TTL_CHECKER,
              WINDOW_EVALUATION_SERVICE,
              STATEFUL_TRIGGER_INFORMATION_UPDATER));

  private static final Set<ThreadName> jvmThreadNames =
      new HashSet<>(
          Arrays.asList(
              JVM_PAUSE_MONITOR,
              JVM_GC_STATISTICS_MONITOR,
              PARALLEL_GC,
              G1_GC,
              G1_MAIN_MARKER,
              G1_REFINE,
              G1_CONC,
              G1_YOUNG_REMSET_SAMPLING,
              COMPILE,
              VM_PERIODIC_TASK,
              VM_THREAD,
              REFERENCE_HANDLER,
              FINALIZER,
              SIGNAL_DISPATCHER,
              DESTROY_JVM,
              COMMON_CLEANER));
  private static final Set<ThreadName> configNodeRpcThreadNames =
      new HashSet<>(
          Arrays.asList(
              CONFIGNODE_RPC_SERVICE, CONFIGNODE_RPC_PROCESSOR, ASYNC_CONFIGNODE_CLIENT_POOL));

  private static final Set<ThreadName> configNodeQueryThreadNames =
      new HashSet<>(Arrays.asList(CQ_SCHEDULER));

  private static final Set<ThreadName> configNodeWriteThreadNames =
      new HashSet<>(Arrays.asList(CONFIG_NODE_SIMPLE_CONSENSUS_WAL_FLUSH));

  private static final Set<ThreadName> configNodeHeartbeatThreadNames =
      new HashSet<>(
          Arrays.asList(
              CONFIG_NODE_HEART_BEAT_SERVICE,
              ASYNC_CONFIGNODE_HEARTBEAT_CLIENT_POOL,
              ASYNC_DATANODE_HEARTBEAT_CLIENT_POOL));

  private static final Set<ThreadName> configNodeLoadBalanceThreadNames =
      new HashSet<>(Arrays.asList(CONFIG_NODE_LOAD_STATISTIC));

  private static final Set<ThreadName> configNodeRegionManagementThreadNames =
      new HashSet<>(Arrays.asList(CONFIG_NODE_REGION_MAINTAINER));

  private static final Set<ThreadName> configNodeRecoverThreadNames =
      new HashSet<>(Arrays.asList(CONFIG_NODE_RECOVER));

  private static final Set<ThreadName> configNodeProcedureThreadNames =
      new HashSet<>(
          Arrays.asList(
              CONFIG_NODE_PROCEDURE_WORKER,
              CONFIG_NODE_WORKER_THREAD_MONITOR,
              CONFIG_NODE_TIMEOUT_EXECUTOR,
              CONFIG_NODE_RETRY_FAILED_TASK));

  private static final Set<ThreadName> metricsThreadNames =
      new HashSet<>(
          Arrays.asList(
              SYSTEM_SCHEDULE_METRICS,
              RESOURCE_CONTROL_DISK_STATISTIC,
              PROMETHEUS_REACTOR_HTTP_EPOLL,
              PROMETHEUS_REACTOR_HTTP_NIO,
              PROMETHEUS_REACTOR_HTTP_EPOLL,
              PROMETHEUS_BOUNDED_ELASTIC));
  private static final Set<ThreadName> otherThreadNames =
      new HashSet<>(
          Arrays.asList(
              TTL_CHECK,
              SETTLE,
              INFLUXDB_RPC_SERVICE,
              INFLUXDB_RPC_PROCESSOR,
              STORAGE_ENGINE_CACHED_POOL,
              MLNODE_RPC_SERVICE,
              IOTDB_SHUTDOWN_HOOK,
              UPGRADE_TASK,
              REGION_MIGRATE,
              STORAGE_ENGINE_RECOVER_TRIGGER));

  private static final Set<ThreadName>[] threadNameSetList =
      new Set[] {
        queryThreadNames,
        mppThreadNames,
        compactionThreadNames,
        walThreadNames,
        flushThreadNames,
        schemaEngineThreadNames,
        clientServiceThreadNames,
        iotConsensusThreadNames,
        ratisThreadNames,
        computeThreadNames,
        jvmThreadNames,
        metricsThreadNames,
        configNodeRpcThreadNames,
        configNodeQueryThreadNames,
        configNodeWriteThreadNames,
        configNodeHeartbeatThreadNames,
        configNodeLoadBalanceThreadNames,
        configNodeRegionManagementThreadNames,
        configNodeRecoverThreadNames,
        configNodeProcedureThreadNames,
        otherThreadNames
      };

  private static final ThreadModule[] modules =
      new ThreadModule[] {
        ThreadModule.QUERY,
        ThreadModule.MPP,
        ThreadModule.COMPACTION,
        ThreadModule.WAL,
        ThreadModule.FLUSH,
        ThreadModule.SCHEMA_ENGINE,
        ThreadModule.CLIENT_SERVICE,
        ThreadModule.IOT_CONSENSUS,
        ThreadModule.RATIS_CONSENSUS,
        ThreadModule.COMPUTE,
        ThreadModule.JVM,
        ThreadModule.METRICS,
        ThreadModule.RPC,
        ThreadModule.QUERY,
        ThreadModule.WRITE,
        ThreadModule.HEARTBEAT,
        ThreadModule.LOAD_BALANCE,
        ThreadModule.REGION_MANAGEMENT,
        ThreadModule.RECOVER,
        ThreadModule.PROCEDURE,
        ThreadModule.OTHER
      };

  ThreadName(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

  public static ThreadModule getModuleTheThreadBelongs(String givenThreadName) {
    for (int i = 0, length = modules.length; i < length; ++i) {
      if (matchModuleWithThreadNames(threadNameSetList[i], modules[i], givenThreadName) != null) {
        return modules[i];
      }
    }
    if (givenThreadName.contains(LOG_BACK.getName())) {
      return ThreadModule.LOG_BACK;
    }

    return ThreadModule.UNKNOWN;
  }

  private static ThreadModule matchModuleWithThreadNames(
      Set<ThreadName> threadNames, ThreadModule module, String givenThreadName) {
    for (ThreadName threadName : threadNames) {
      if (threadName.getName().contains("\\d")) {
        if (Pattern.compile(threadName.getName()).matcher(givenThreadName).find()) {
          return module;
        }
      } else if (givenThreadName.contains(threadName.getName())) {
        return module;
      }
    }
    return null;
  }

  public static ThreadName getThreadPoolTheThreadBelongs(String givenThreadName) {
    ThreadName[] threadNames = ThreadName.values();
    for (ThreadName threadName : threadNames) {
      String name = threadName.getName();
      if (name.contains("\\d")) {
        // regex pattern
        if (Pattern.compile(name).matcher(givenThreadName).find()) {
          return threadName;
        }
      } else {
        if (givenThreadName.contains(name)) {
          return threadName;
        }
      }
    }
    log.debug("Unknown thread name: {}", givenThreadName);
    return ThreadName.UNKOWN;
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one
3	* or more contributor license agreements. See the NOTICE file
4	* distributed with this work for additional information
5	* regarding copyright ownership. The ASF licenses this file
6	* to you under the Apache License, Version 2.0 (the
7	* "License"); you may not use this file except in compliance
8	* with the License. You may obtain a copy of the License at
9	*
10	* http://www.apache.org/licenses/LICENSE-2.0
11	*
12	* Unless required by applicable law or agreed to in writing,
13	* software distributed under the License is distributed on an
14	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	* KIND, either express or implied. See the License for the
16	* specific language governing permissions and limitations
17	* under the License.
18	*/
19	package org.apache.iotdb.commons.concurrent;
20
21	import org.slf4j.Logger;
22	import org.slf4j.LoggerFactory;
23
24	import java.util.Arrays;
25	import java.util.HashSet;
26	import java.util.Set;
27	import java.util.regex.Pattern;
28
29	public enum ThreadName {	1✔
30	// -------------------------- QueryThread --------------------------
31	QUERY_WORKER("Query-Worker-Thread"),	1✔
32	QUERY_SENTINEL("Query-Sentinel-Thread"),	1✔
33	TIMED_QUERY_SQL_COUNT("Timed-Query-SQL-Count"),	1✔
34	FRAGMENT_INSTANCE_MANAGEMENT("Fragment-Instance-Management"),	1✔
35	FRAGMENT_INSTANCE_NOTIFICATION("Fragment-Instance-Notification"),	1✔
36	DRIVER_TASK_SCHEDULER_NOTIFICATION("Driver-Task-Scheduler-Notification"),	1✔
37	// -------------------------- MPP --------------------------
38	MPP_COORDINATOR_SCHEDULED_EXECUTOR("MPP-Coordinator-Scheduled-Executor"),	1✔
39	MPP_DATA_EXCHANGE_TASK_EXECUTOR("MPP-Data-Exchange-Task-Executors"),	1✔
40	ASYNC_DATANODE_CLIENT_POOL("AsyncDataNodeInternalServiceClientPool"),	1✔
41	MPP_DATA_EXCHANGE_RPC_SERVICE("MPPDataExchangeRPC-Service"),	1✔
42	MPP_DATA_EXCHANGE_RPC_PROCESSOR("MPPDataExchangeRPC-Processor"),	1✔
43	MPP_COORDINATOR_EXECUTOR_POOL("MPP-Coordinator-Executor"),	1✔
44	DATANODE_INTERNAL_RPC_SERVICE("DataNodeInternalRPC-Service"),	1✔
45	DATANODE_INTERNAL_RPC_PROCESSOR("DataNodeInternalRPC-Processor"),	1✔
46	MPP_COORDINATOR_WRITE_EXECUTOR("MPP-Coordinator-Write-Executor"),	1✔
47	ASYNC_DATANODE_MPP_DATA_EXCHANGE_CLIENT_POOL("AsyncDataNodeMPPDataExchangeServiceClientPool"),	1✔
48
49	// -------------------------- Compaction --------------------------
50	COMPACTION_WORKER("Compaction-Worker"),	1✔
51	COMPACTION_SUB_TASK("Compaction-Sub-Task"),	1✔
52	COMPACTION_SCHEDULE("Compaction-Schedule"),	1✔
53	// -------------------------- Wal --------------------------
54	WAL_SERIALIZE("WAL-Serialize"),	1✔
55	WAL_SYNC("WAL-Sync"),	1✔
56	WAL_DELETE("WAL-Delete"),	1✔
57	WAL_RECOVER("WAL-Recover"),	1✔
58	TSFILE_RECOVER("TsFile-Recover"),	1✔
59	// -------------------------- Flush --------------------------
60	FLUSH("Flush"),	1✔
61	FLUSH_SUB_TASK("Flush-SubTask"),	1✔
62	FLUSH_TASK_SUBMIT("FlushTask-Submit-Pool"),	1✔
63	TIMED_FLUSH_SEQ_MEMTABLE("Timed-Flush-Seq-Memtable"),	1✔
64	TIMED_FLUSH_UNSEQ_MEMTABLE("Timed-Flush-Unseq-Memtable"),	1✔
65	// -------------------------- SchemaEngine --------------------------
66	SCHEMA_REGION_RELEASE_PROCESSOR("SchemaRegion-Release-Task-Processor"),	1✔
67	SCHEMA_REGION_RECOVER_TASK("SchemaRegion-recover-task"),	1✔
68	SCHEMA_RELEASE_MONITOR("Schema-Release-Task-Monitor"),	1✔
69	SCHEMA_REGION_FLUSH_PROCESSOR("SchemaRegion-Flush-Task-Processor"),	1✔
70	SCHEMA_FLUSH_MONITOR("Schema-Flush-Task-Monitor"),	1✔
71	SCHEMA_FORCE_MLOG("SchemaEngine-TimedForceMLog-Thread"),	1✔
72	// -------------------------- ClientService --------------------------
73	CLIENT_RPC_SERVICE("ClientRPC-Service"),	1✔
74	CLIENT_RPC_PROCESSOR("ClientRPC-Processor"),	1✔
75	// -------------------------- ConfigNode-RPC --------------------------
76	CONFIGNODE_RPC_SERVICE("ConfigNodeRPC-Service"),	1✔
77	CONFIGNODE_RPC_PROCESSOR("ConfigNodeRPC-Processor"),	1✔
78	ASYNC_CONFIGNODE_CLIENT_POOL("AsyncConfigNodeIServiceClientPool"),	1✔
79	// -------------------------- ConfigNode-Query --------------------------
80	CQ_SCHEDULER("CQ-Scheduler"),	1✔
81	// -------------------------- ConfigNode-Write --------------------------
82	CONFIG_NODE_SIMPLE_CONSENSUS_WAL_FLUSH("ConfigNode-Simple-Consensus-WAL-Flush-Thread"),	1✔
83	// -------------------------- ConfigNode-Heartbeat --------------------------
84	CONFIG_NODE_HEART_BEAT_SERVICE("Cluster-Heartbeat-Service"),	1✔
85	ASYNC_CONFIGNODE_HEARTBEAT_CLIENT_POOL("AsyncConfigNodeHeartbeatServiceClientPool"),	1✔
86	ASYNC_DATANODE_HEARTBEAT_CLIENT_POOL("AsyncDataNodeHeartbeatServiceClientPool"),	1✔
87	// -------------------------- ConfigNode-LoadBalance --------------------------
88	CONFIG_NODE_LOAD_STATISTIC("Cluster-LoadStatistics-Service"),	1✔
89	// -------------------------- ConfigNode-RegionManagement --------------------------
90	CONFIG_NODE_REGION_MAINTAINER("IoTDB-Region-Maintainer"),	1✔
91	// -------------------------- ConfigNode-Recover --------------------------
92	CONFIG_NODE_RECOVER("ConfigNode-Manager-Recovery"),	1✔
93	// -------------------------- ConfigNode-Procedure ------------------------
94	// TODO: Use Thread Pool to manage the procedure thread @Potato
95	CONFIG_NODE_PROCEDURE_WORKER("ProcedureWorkerGroup"),	1✔
96	CONFIG_NODE_TIMEOUT_EXECUTOR("ProcedureTimeoutExecutor"),	1✔
97	CONFIG_NODE_WORKER_THREAD_MONITOR("ProcedureWorkerThreadMonitor"),	1✔
98	CONFIG_NODE_RETRY_FAILED_TASK("Cluster-RetryFailedTasks-Service"),	1✔
99
100	// -------------------------- IoTConsensus --------------------------
101	IOT_CONSENSUS_RPC_SERVICE("IoTConsensusRPC-Service"),	1✔
102	IOT_CONSENSUS_RPC_PROCESSOR("IoTConsensusRPC-Processor"),	1✔
103	ASYNC_DATANODE_IOT_CONSENSUS_CLIENT_POOL("AsyncDataNodeIoTConsensusServiceClientPool"),	1✔
104	LOG_DISPATCHER("LogDispatcher"),	1✔
105	// -------------------------- Ratis --------------------------
106	// NOTICE: The thread name of ratis cannot be edited here!
107	// We list the thread name here just for distinguishing what module the thread belongs to.
108	RAFT_SERVER_PROXY_EXECUTOR("\\d+-impl-thread"),	1✔
109	RAFT_SERVER_EXECUTOR("\\d+-server-thread"),	1✔
110	RAFT_SERVER_CLIENT_EXECUTOR("\\d+-client-thread"),	1✔
111	RATIS_ADD("Ratis-Add"),	1✔
112	SEGMENT_RAFT_WORKER("SegmentedRaftLogWorker"),	1✔
113	STATE_MACHINE_UPDATER("StateMachineUpdater"),	1✔
114	FOLLOWER_STATE("FollowerState"),	1✔
115	LEADER_STATE_IMPL_PROCESSOR("LeaderStateImpl"),	1✔
116	LEADER_ELECTION("LeaderElection"),	1✔
117	LOG_APPENDER("GrpcLogAppender"),	1✔
118	EVENT_PROCESSOR("EventProcessor"),	1✔
119	RATIS_BG_DISK_GUARDIAN("RatisBgDiskGuardian"),	1✔
120	GRPC_DEFAULT_BOSS_ELG("grpc-default-boss-ELG"),	1✔
121	GRPC_DEFAULT_EXECUTOR("grpc-default-executor"),	1✔
122	GPRC_DEFAULT_WORKER_ELG("grpc-default-worker-ELG"),	1✔
123	GROUP_MANAGEMENT("groupManagement"),	1✔
124	// -------------------------- Compute --------------------------
125	PIPE_ASSIGNER_EXECUTOR_POOL("Pipe-Assigner-Executor-Pool"),	1✔
126	PIPE_PROCESSOR_EXECUTOR_POOL("Pipe-Processor-Executor-Pool"),	1✔
127	PIPE_CONNECTOR_EXECUTOR_POOL("Pipe-Connector-Executor-Pool"),	1✔
128	PIPE_SUBTASK_CALLBACK_EXECUTOR_POOL("Pipe-SubTask-Callback-Executor-Pool"),	1✔
129	PIPE_RUNTIME_META_SYNCER("Pipe-Runtime-Meta-Syncer"),	1✔
130	PIPE_RUNTIME_HEARTBEAT("Pipe-Runtime-Heartbeat"),	1✔
131	PIPE_RUNTIME_PROCEDURE_SUBMITTER("Pipe-Runtime-Procedure-Submitter"),	1✔
132	PIPE_ASYNC_CONNECTOR_CLIENT_POOL("Pipe-Async-Connector-Client-Pool"),	1✔
133	PIPE_ASYNC_CONNECTOR_RETRY_TRIGGER("Pipe-Async-Connector-Retry-Trigger"),	1✔
134	PIPE_WAL_RESOURCE_TTL_CHECKER("Pipe-WAL-Resource-TTL-Checker"),	1✔
135	WINDOW_EVALUATION_SERVICE("WindowEvaluationTaskPoolManager"),	1✔
136	STATEFUL_TRIGGER_INFORMATION_UPDATER("Stateful-Trigger-Information-Updater"),	1✔
137	// -------------------------- JVM --------------------------
138	// NOTICE: The thread name of jvm cannot be edited here!
139	// We list the thread name here just for distinguishing what module the thread belongs to.
140	JVM_PAUSE_MONITOR("JvmPauseMonitor"),	1✔
141	JVM_GC_STATISTICS_MONITOR("JVM-GC-Statistics-Monitor"),	1✔
142	PARALLEL_GC("GC task thread"),	1✔
143	G1_GC("GC Thread"),	1✔
144	G1_MAIN_MARKER("G1 Main Marker"),	1✔
145	G1_CONC("G1 Conc"),	1✔
146	G1_REFINE("G1 Refine"),	1✔
147	G1_YOUNG_REMSET_SAMPLING("G1 Young RemSet Sampling"),	1✔
148	COMPILE("CompilerThread"),	1✔
149	VM_PERIODIC_TASK("VM Periodic Task Thread"),	1✔
150	VM_THREAD("VM Thread"),	1✔
151	REFERENCE_HANDLER("Reference Handler"),	1✔
152	FINALIZER("Finalizer"),	1✔
153	SIGNAL_DISPATCHER("Signal Dispatcher"),	1✔
154	DESTROY_JVM("DestroyJavaVM"),	1✔
155	COMMON_CLEANER("Common-Cleaner"),	1✔
156	// -------------------------- LogThread --------------------------
157	LOG_BACK("logback"),	1✔
158	// -------------------------- Metrics --------------------------
159	SYSTEM_SCHEDULE_METRICS("SystemScheduleMetrics"),	1✔
160	RESOURCE_CONTROL_DISK_STATISTIC("ResourceControl-DataRegionDiskStatistics"),	1✔
161	PROMETHEUS_REACTOR_HTTP_EPOLL("reactor-http-epoll"),	1✔
162	PROMETHEUS_REACTOR_HTTP_NIO("reactor-http-nio"),	1✔
163	PROMETHEUS_BOUNDED_ELASTIC("boundedElastic-evictor"),	1✔
164	// -------------------------- Other --------------------------
165	TTL_CHECK("TTL-CHECK"),	1✔
166	SETTLE("Settle"),	1✔
167	INFLUXDB_RPC_SERVICE("InfluxdbRPC-Service"),	1✔
168	INFLUXDB_RPC_PROCESSOR("InfluxdbRPC-Processor"),	1✔
169	STORAGE_ENGINE_CACHED_POOL("StorageEngine"),	1✔
170	MLNODE_RPC_SERVICE("MLNodeRpc-Service"),	1✔
171	IOTDB_SHUTDOWN_HOOK("IoTDB-Shutdown-Hook"),	1✔
172	UPGRADE_TASK("UpgradeThread"),	1✔
173	REGION_MIGRATE("Region-Migrate-Pool"),	1✔
174	STORAGE_ENGINE_RECOVER_TRIGGER("StorageEngine-RecoverTrigger"),	1✔
175	// the unknown thread name is used for metrics
176	UNKOWN("UNKNOWN");	1✔
177
178	private final String name;
179	private static final Logger log = LoggerFactory.getLogger(ThreadName.class);	1✔
180	private static final Set<ThreadName> queryThreadNames =	1✔
181	new HashSet<>(
182	Arrays.asList(	1✔
183	QUERY_WORKER,
184	QUERY_SENTINEL,
185	TIMED_QUERY_SQL_COUNT,
186	FRAGMENT_INSTANCE_MANAGEMENT,
187	FRAGMENT_INSTANCE_NOTIFICATION,
188	DRIVER_TASK_SCHEDULER_NOTIFICATION));
189	private static final Set<ThreadName> mppThreadNames =	1✔
190	new HashSet<>(
191	Arrays.asList(	1✔
192	MPP_COORDINATOR_SCHEDULED_EXECUTOR,
193	MPP_DATA_EXCHANGE_TASK_EXECUTOR,
194	ASYNC_DATANODE_CLIENT_POOL,
195	MPP_DATA_EXCHANGE_RPC_SERVICE,
196	MPP_DATA_EXCHANGE_RPC_PROCESSOR,
197	MPP_COORDINATOR_EXECUTOR_POOL,
198	DATANODE_INTERNAL_RPC_SERVICE,
199	DATANODE_INTERNAL_RPC_PROCESSOR,
200	MPP_COORDINATOR_WRITE_EXECUTOR,
201	ASYNC_DATANODE_MPP_DATA_EXCHANGE_CLIENT_POOL));
202	private static final Set<ThreadName> compactionThreadNames =	1✔
203	new HashSet<>(Arrays.asList(COMPACTION_WORKER, COMPACTION_SUB_TASK, COMPACTION_SCHEDULE));	1✔
204
205	private static final Set<ThreadName> walThreadNames =	1✔
206	new HashSet<>(
207	Arrays.asList(WAL_SERIALIZE, WAL_SYNC, WAL_DELETE, WAL_RECOVER, TSFILE_RECOVER));	1✔
208
209	private static final Set<ThreadName> flushThreadNames =	1✔
210	new HashSet<>(
211	Arrays.asList(	1✔
212	FLUSH,
213	FLUSH_SUB_TASK,
214	FLUSH_TASK_SUBMIT,
215	TIMED_FLUSH_SEQ_MEMTABLE,
216	TIMED_FLUSH_UNSEQ_MEMTABLE));
217	private static final Set<ThreadName> schemaEngineThreadNames =	1✔
218	new HashSet<>(
219	Arrays.asList(	1✔
220	SCHEMA_REGION_RELEASE_PROCESSOR,
221	SCHEMA_REGION_RECOVER_TASK,
222	SCHEMA_RELEASE_MONITOR,
223	SCHEMA_REGION_FLUSH_PROCESSOR,
224	SCHEMA_FLUSH_MONITOR,
225	SCHEMA_FORCE_MLOG));
226
227	private static final Set<ThreadName> clientServiceThreadNames =	1✔
228	new HashSet<>(Arrays.asList(CLIENT_RPC_SERVICE, CLIENT_RPC_PROCESSOR));	1✔
229
230	private static final Set<ThreadName> iotConsensusThreadNames =	1✔
231	new HashSet<>(
232	Arrays.asList(	1✔
233	IOT_CONSENSUS_RPC_SERVICE,
234	IOT_CONSENSUS_RPC_PROCESSOR,
235	ASYNC_DATANODE_IOT_CONSENSUS_CLIENT_POOL,
236	LOG_DISPATCHER));
237
238	private static final Set<ThreadName> ratisThreadNames =	1✔
239	new HashSet<>(
240	Arrays.asList(	1✔
241	RAFT_SERVER_PROXY_EXECUTOR,
242	RAFT_SERVER_EXECUTOR,
243	RAFT_SERVER_CLIENT_EXECUTOR,
244	RATIS_ADD,
245	SEGMENT_RAFT_WORKER,
246	STATE_MACHINE_UPDATER,
247	FOLLOWER_STATE,
248	LEADER_STATE_IMPL_PROCESSOR,
249	LEADER_ELECTION,
250	LOG_APPENDER,
251	EVENT_PROCESSOR,
252	RATIS_BG_DISK_GUARDIAN,
253	GRPC_DEFAULT_BOSS_ELG,
254	GPRC_DEFAULT_WORKER_ELG,
255	GRPC_DEFAULT_EXECUTOR,
256	GROUP_MANAGEMENT));
257	private static final Set<ThreadName> computeThreadNames =	1✔
258	new HashSet<>(
259	Arrays.asList(	1✔
260	PIPE_ASSIGNER_EXECUTOR_POOL,
261	PIPE_PROCESSOR_EXECUTOR_POOL,
262	PIPE_CONNECTOR_EXECUTOR_POOL,
263	PIPE_SUBTASK_CALLBACK_EXECUTOR_POOL,
264	PIPE_RUNTIME_META_SYNCER,
265	PIPE_RUNTIME_HEARTBEAT,
266	PIPE_RUNTIME_PROCEDURE_SUBMITTER,
267	PIPE_ASYNC_CONNECTOR_CLIENT_POOL,
268	PIPE_ASYNC_CONNECTOR_RETRY_TRIGGER,
269	PIPE_WAL_RESOURCE_TTL_CHECKER,
270	WINDOW_EVALUATION_SERVICE,
271	STATEFUL_TRIGGER_INFORMATION_UPDATER));
272
273	private static final Set<ThreadName> jvmThreadNames =	1✔
274	new HashSet<>(
275	Arrays.asList(	1✔
276	JVM_PAUSE_MONITOR,
277	JVM_GC_STATISTICS_MONITOR,
278	PARALLEL_GC,
279	G1_GC,
280	G1_MAIN_MARKER,
281	G1_REFINE,
282	G1_CONC,
283	G1_YOUNG_REMSET_SAMPLING,
284	COMPILE,
285	VM_PERIODIC_TASK,
286	VM_THREAD,
287	REFERENCE_HANDLER,
288	FINALIZER,
289	SIGNAL_DISPATCHER,
290	DESTROY_JVM,
291	COMMON_CLEANER));
292	private static final Set<ThreadName> configNodeRpcThreadNames =	1✔
293	new HashSet<>(
294	Arrays.asList(	1✔
295	CONFIGNODE_RPC_SERVICE, CONFIGNODE_RPC_PROCESSOR, ASYNC_CONFIGNODE_CLIENT_POOL));
296
297	private static final Set<ThreadName> configNodeQueryThreadNames =	1✔
298	new HashSet<>(Arrays.asList(CQ_SCHEDULER));	1✔
299
300	private static final Set<ThreadName> configNodeWriteThreadNames =	1✔
301	new HashSet<>(Arrays.asList(CONFIG_NODE_SIMPLE_CONSENSUS_WAL_FLUSH));	1✔
302
303	private static final Set<ThreadName> configNodeHeartbeatThreadNames =	1✔
304	new HashSet<>(
305	Arrays.asList(	1✔
306	CONFIG_NODE_HEART_BEAT_SERVICE,
307	ASYNC_CONFIGNODE_HEARTBEAT_CLIENT_POOL,
308	ASYNC_DATANODE_HEARTBEAT_CLIENT_POOL));
309
310	private static final Set<ThreadName> configNodeLoadBalanceThreadNames =	1✔
311	new HashSet<>(Arrays.asList(CONFIG_NODE_LOAD_STATISTIC));	1✔
312
313	private static final Set<ThreadName> configNodeRegionManagementThreadNames =	1✔
314	new HashSet<>(Arrays.asList(CONFIG_NODE_REGION_MAINTAINER));	1✔
315
316	private static final Set<ThreadName> configNodeRecoverThreadNames =	1✔
317	new HashSet<>(Arrays.asList(CONFIG_NODE_RECOVER));	1✔
318
319	private static final Set<ThreadName> configNodeProcedureThreadNames =	1✔
320	new HashSet<>(
321	Arrays.asList(	1✔
322	CONFIG_NODE_PROCEDURE_WORKER,
323	CONFIG_NODE_WORKER_THREAD_MONITOR,
324	CONFIG_NODE_TIMEOUT_EXECUTOR,
325	CONFIG_NODE_RETRY_FAILED_TASK));
326
327	private static final Set<ThreadName> metricsThreadNames =	1✔
328	new HashSet<>(
329	Arrays.asList(	1✔
330	SYSTEM_SCHEDULE_METRICS,
331	RESOURCE_CONTROL_DISK_STATISTIC,
332	PROMETHEUS_REACTOR_HTTP_EPOLL,
333	PROMETHEUS_REACTOR_HTTP_NIO,
334	PROMETHEUS_REACTOR_HTTP_EPOLL,
335	PROMETHEUS_BOUNDED_ELASTIC));
336	private static final Set<ThreadName> otherThreadNames =	1✔
337	new HashSet<>(
338	Arrays.asList(	1✔
339	TTL_CHECK,
340	SETTLE,
341	INFLUXDB_RPC_SERVICE,
342	INFLUXDB_RPC_PROCESSOR,
343	STORAGE_ENGINE_CACHED_POOL,
344	MLNODE_RPC_SERVICE,
345	IOTDB_SHUTDOWN_HOOK,
346	UPGRADE_TASK,
347	REGION_MIGRATE,
348	STORAGE_ENGINE_RECOVER_TRIGGER));
349
350	private static final Set<ThreadName>[] threadNameSetList =	1✔
351	new Set[] {
352	queryThreadNames,
353	mppThreadNames,
354	compactionThreadNames,
355	walThreadNames,
356	flushThreadNames,
357	schemaEngineThreadNames,
358	clientServiceThreadNames,
359	iotConsensusThreadNames,
360	ratisThreadNames,
361	computeThreadNames,
362	jvmThreadNames,
363	metricsThreadNames,
364	configNodeRpcThreadNames,
365	configNodeQueryThreadNames,
366	configNodeWriteThreadNames,
367	configNodeHeartbeatThreadNames,
368	configNodeLoadBalanceThreadNames,
369	configNodeRegionManagementThreadNames,
370	configNodeRecoverThreadNames,
371	configNodeProcedureThreadNames,
372	otherThreadNames
373	};
374
375	private static final ThreadModule[] modules =	1✔
376	new ThreadModule[] {
377	ThreadModule.QUERY,
378	ThreadModule.MPP,
379	ThreadModule.COMPACTION,
380	ThreadModule.WAL,
381	ThreadModule.FLUSH,
382	ThreadModule.SCHEMA_ENGINE,
383	ThreadModule.CLIENT_SERVICE,
384	ThreadModule.IOT_CONSENSUS,
385	ThreadModule.RATIS_CONSENSUS,
386	ThreadModule.COMPUTE,
387	ThreadModule.JVM,
388	ThreadModule.METRICS,
389	ThreadModule.RPC,
390	ThreadModule.QUERY,
391	ThreadModule.WRITE,
392	ThreadModule.HEARTBEAT,
393	ThreadModule.LOAD_BALANCE,
394	ThreadModule.REGION_MANAGEMENT,
395	ThreadModule.RECOVER,
396	ThreadModule.PROCEDURE,
397	ThreadModule.OTHER
398	};
399
400	ThreadName(String name) {	1✔
401	this.name = name;	1✔
402	}	1✔
403
404	public String getName() {
405	return name;	1✔
406	}
407
408	public static ThreadModule getModuleTheThreadBelongs(String givenThreadName) {
409	for (int i = 0, length = modules.length; i < length; ++i) {	×
410	if (matchModuleWithThreadNames(threadNameSetList[i], modules[i], givenThreadName) != null) {	×
411	return modules[i];	×
412	}
413	}
414	if (givenThreadName.contains(LOG_BACK.getName())) {	×
415	return ThreadModule.LOG_BACK;	×
416	}
417
418	return ThreadModule.UNKNOWN;	×
419	}
420
421	private static ThreadModule matchModuleWithThreadNames(
422	Set<ThreadName> threadNames, ThreadModule module, String givenThreadName) {
423	for (ThreadName threadName : threadNames) {	×
424	if (threadName.getName().contains("\\d")) {	×
425	if (Pattern.compile(threadName.getName()).matcher(givenThreadName).find()) {	×
426	return module;	×
427	}
428	} else if (givenThreadName.contains(threadName.getName())) {	×
429	return module;	×
430	}
431	}	×
432	return null;	×
433	}
434
435	public static ThreadName getThreadPoolTheThreadBelongs(String givenThreadName) {
436	ThreadName[] threadNames = ThreadName.values();	×
437	for (ThreadName threadName : threadNames) {	×
438	String name = threadName.getName();	×
439	if (name.contains("\\d")) {	×
440	// regex pattern
441	if (Pattern.compile(name).matcher(givenThreadName).find()) {	×
442	return threadName;	×
443	}
444	} else {
445	if (givenThreadName.contains(name)) {	×
446	return threadName;	×
447	}
448	}
449	}
450	log.debug("Unknown thread name: {}", givenThreadName);	×
451	return ThreadName.UNKOWN;	×
452	}
453	}

apache / iotdb / #9708

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous