diff --git a/src/balance/src/bnThread.c b/src/balance/src/bnThread.c
index 44cb24effa09688db79bb9ae8fa40a381c0c0404..c5dca2da8596dffbbee6417281a739cec7bba016 100644
--- a/src/balance/src/bnThread.c
+++ b/src/balance/src/bnThread.c
@@ -23,6 +23,8 @@
 static SBnThread tsBnThread;
 
 static void *bnThreadFunc(void *arg) {
+  setThreadName("bnThreadd");
+
   while (1) {
     pthread_mutex_lock(&tsBnThread.mutex);
     if (tsBnThread.stop) {
diff --git a/src/dnode/src/dnodeMPeer.c b/src/dnode/src/dnodeMPeer.c
index e4942c49aaba48db8d2a1c74a0af532769de9553..8aa28d1618efe871de7795b0d403ee060cf5941c 100644
--- a/src/dnode/src/dnodeMPeer.c
+++ b/src/dnode/src/dnodeMPeer.c
@@ -150,6 +150,8 @@ static void *dnodeProcessMPeerQueue(void *param) {
   SMnodeMsg *pPeerMsg;
   int32_t    type;
   void *     unUsed;
+
+  setThreadName("dnodeMPeerQ");
   
   while (1) {
     if (taosReadQitemFromQset(tsMPeerQset, &type, (void **)&pPeerMsg, &unUsed) == 0) {
diff --git a/src/dnode/src/dnodeMRead.c b/src/dnode/src/dnodeMRead.c
index 90332e6783bc4861928833d5794f0787f80be993..184a6b743afdd5f4284a5acffc8d518356be4ee4 100644
--- a/src/dnode/src/dnodeMRead.c
+++ b/src/dnode/src/dnodeMRead.c
@@ -155,6 +155,8 @@ static void *dnodeProcessMReadQueue(void *param) {
   int32_t    type;
   void *     unUsed;
 
+  setThreadName("dnodeMReadQ");
+
   while (1) {
     if (taosReadQitemFromQset(tsMReadQset, &type, (void **)&pRead, &unUsed) == 0) {
       dDebug("qset:%p, mnode read got no message from qset, exiting", tsMReadQset);
diff --git a/src/dnode/src/dnodeMWrite.c b/src/dnode/src/dnodeMWrite.c
index a409d537fa8a56f03ed79d68358ac70b780e74e9..904ddc21d019343fa3f679db4d25cd9b01e1d97b 100644
--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
@@ -168,7 +168,9 @@ static void *dnodeProcessMWriteQueue(void *param) {
   SMnodeMsg *pWrite;
   int32_t    type;
   void *     unUsed;
-  
+
+  setThreadName("dnodeMWriteQ");
+
   while (1) {
     if (taosReadQitemFromQset(tsMWriteQset, &type, (void **)&pWrite, &unUsed) == 0) {
       dDebug("qset:%p, mnode write got no message from qset, exiting", tsMWriteQset);
diff --git a/src/dnode/src/dnodeTelemetry.c b/src/dnode/src/dnodeTelemetry.c
index 4caece16612353155886ff20055433878ec7411c..59b66879d42e3133ec7143c95f31c9b5df8ddb60 100644
--- a/src/dnode/src/dnodeTelemetry.c
+++ b/src/dnode/src/dnodeTelemetry.c
@@ -245,6 +245,8 @@ static void* telemetryThread(void* param) {
   clock_gettime(CLOCK_REALTIME, &end);
   end.tv_sec += 300; // wait 5 minutes before send first report
 
+  setThreadName("telemetryThrd");
+
   while (!tsExit) {
     int r = 0;
     struct timespec ts = end;
diff --git a/src/dnode/src/dnodeVMgmt.c b/src/dnode/src/dnodeVMgmt.c
index daf62aac94a5e10a5899ad9c8593b5ff7df86f46..c1bfb1460b4b3058434c628f503a4775c4c24701 100644
--- a/src/dnode/src/dnodeVMgmt.c
+++ b/src/dnode/src/dnodeVMgmt.c
@@ -103,6 +103,8 @@ static void *dnodeProcessMgmtQueue(void *wparam) {
   int32_t      qtype;
   void *       handle;
 
+  setThreadName("dnodeMgmtQ");
+
   while (1) {
     if (taosReadQitemFromQset(pPool->qset, &qtype, (void **)&pMgmt, &handle) == 0) {
       dDebug("qdnode mgmt got no message from qset:%p, , exit", pPool->qset);
diff --git a/src/dnode/src/dnodeVRead.c b/src/dnode/src/dnodeVRead.c
index 41016d7b99d049922e4de7dc0cbd3dafd2bc4ebf..e8003a8fe7996316d0b91689ea9738cbd24184b9 100644
--- a/src/dnode/src/dnodeVRead.c
+++ b/src/dnode/src/dnodeVRead.c
@@ -118,6 +118,11 @@ static void *dnodeProcessReadQueue(void *wparam) {
   SVReadMsg *  pRead;
   int32_t      qtype;
   void *       pVnode;
+  char         name[16];
+
+  memset(name, 0, 16);
+  snprintf(name, 16, "%s-dnReadQ", pPool->name);
+  setThreadName(name);
 
   while (1) {
     if (taosReadQitemFromQset(pPool->qset, &qtype, (void **)&pRead, &pVnode) == 0) {
diff --git a/src/dnode/src/dnodeVWrite.c b/src/dnode/src/dnodeVWrite.c
index ff2d12f001710b5ddcd310cff03929fd3c038782..ed2a6e210939e907e89dd07de27481d385e4ef24 100644
--- a/src/dnode/src/dnodeVWrite.c
+++ b/src/dnode/src/dnodeVWrite.c
@@ -191,6 +191,8 @@ static void *dnodeProcessVWriteQueue(void *wparam) {
   taosBlockSIGPIPE();
   dDebug("dnode vwrite worker:%d is running", pWorker->workerId);
 
+  setThreadName("dnodeWriteQ");
+
   while (1) {
     numOfMsgs = taosReadAllQitemsFromQset(pWorker->qset, pWorker->qall, &pVnode);
     if (numOfMsgs == 0) {
diff --git a/src/dnode/src/dnodeVnodes.c b/src/dnode/src/dnodeVnodes.c
index f01a510370758a04fe8972304ae352b796dc6e35..8ea8e280de10f0657ad0b937fb78794175d8c20a 100644
--- a/src/dnode/src/dnodeVnodes.c
+++ b/src/dnode/src/dnodeVnodes.c
@@ -91,6 +91,8 @@ static void *dnodeOpenVnode(void *param) {
 
   dDebug("thread:%d, start to open %d vnodes", pThread->threadIndex, pThread->vnodeNum);
 
+  setThreadName("dnodeOpenVnode");
+
   for (int32_t v = 0; v < pThread->vnodeNum; ++v) {
     int32_t vgId = pThread->vnodeList[v];
     snprintf(stepDesc, TSDB_STEP_DESC_LEN, "vgId:%d, start to restore, %d of %d have been opened", vgId, tsOpenVnodes, tsTotalVnodes);
diff --git a/src/kit/shell/src/shellCheck.c b/src/kit/shell/src/shellCheck.c
index 4ff5dc36fc72bf2bfaa7ffea3f6a47c619c6235b..d78f1a6b996110f9cdce37e60dfbb85323a3a848 100644
--- a/src/kit/shell/src/shellCheck.c
+++ b/src/kit/shell/src/shellCheck.c
@@ -104,6 +104,8 @@ static void shellFreeTbnames() {
 static void *shellCheckThreadFp(void *arg) {
   ShellThreadObj *pThread = (ShellThreadObj *)arg;
 
+  setThreadName("shellCheckThrd");
+
   int32_t interval = tbNum / pThread->totalThreads + 1;
   int32_t start = pThread->threadIndex * interval;
   int32_t end = (pThread->threadIndex + 1) * interval;
diff --git a/src/kit/shell/src/shellDarwin.c b/src/kit/shell/src/shellDarwin.c
index 31ad7046e9176221e10c79b3f2367ea464529438..86c0fea5739ff624cada266e09920f875c24a69a 100644
--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -336,6 +336,8 @@ void *shellLoopQuery(void *arg) {
 
   TAOS *con = (TAOS *)arg;
 
+  setThreadName("shellLoopQuery");
+
   pthread_cleanup_push(cleanup_handler, NULL);
 
     char *command = malloc(MAX_COMMAND_SIZE);
diff --git a/src/kit/shell/src/shellImport.c b/src/kit/shell/src/shellImport.c
index 5de50a3aaf70074da0592e628b932e49aaf89c48..222d69e854933095ec0aadaa8a67bf1c19954c3b 100644
--- a/src/kit/shell/src/shellImport.c
+++ b/src/kit/shell/src/shellImport.c
@@ -223,6 +223,8 @@ static void shellSourceFile(TAOS *con, char *fptr) {
 void* shellImportThreadFp(void *arg)
 {
   ShellThreadObj *pThread = (ShellThreadObj*)arg;
+  setThreadName("shellImportThrd");
+
   for (int f = 0; f < shellSQLFileNum; ++f) {
     if (f % pThread->totalThreads == pThread->threadIndex) {
       char *SQLFileName = shellSQLFiles[f];
diff --git a/src/kit/shell/src/shellLinux.c b/src/kit/shell/src/shellLinux.c
index 4eead252fd4c47893ba966c1686d375fd7b9b6dc..2a32a8d82e73794fbea930c174d6e51f9c194fc3 100644
--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -336,6 +336,8 @@ void *shellLoopQuery(void *arg) {
 
   TAOS *con = (TAOS *)arg;
 
+  setThreadName("shellLoopQuery");
+
   pthread_cleanup_push(cleanup_handler, NULL);
 
   char *command = malloc(MAX_COMMAND_SIZE);
diff --git a/src/kit/shell/src/shellMain.c b/src/kit/shell/src/shellMain.c
index 4c7e550760cecb7c045cb8c94fc431cb5f91812b..0c70386061b99baaf2f9448ddadbb250685f23d4 100644
--- a/src/kit/shell/src/shellMain.c
+++ b/src/kit/shell/src/shellMain.c
@@ -26,6 +26,8 @@ void shellQueryInterruptHandler(int32_t signum, void *sigInfo, void *context) {
 }
 
 void *cancelHandler(void *arg) {
+  setThreadName("cancelHandler");
+
   while(1) {
     if (tsem_wait(&cancelSem) != 0) {
       taosMsleep(10);
diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 2beb0c8e7efc3b0348d37264358fa4c64219de16..a15caa008e7e1b279c3a8e990d7e430868a25b85 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -3025,10 +3025,11 @@ static void* createTable(void *sarg)
     threadInfo *pThreadInfo = (threadInfo *)sarg;
     SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
 
+    setThreadName("createTable");
+
     uint64_t  lastPrintTime = taosGetTimestampMs();
 
-    int buff_len;
-    buff_len = BUFFER_SIZE;
+    int buff_len = BUFFER_SIZE;
 
     pThreadInfo->buffer = calloc(buff_len, 1);
     if (pThreadInfo->buffer == NULL) {
@@ -6428,6 +6429,8 @@ static void* syncWrite(void *sarg) {
     threadInfo *pThreadInfo = (threadInfo *)sarg;
     SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
 
+    setThreadName("syncWrite");
+
     uint32_t interlaceRows;
 
     if (superTblInfo) {
@@ -6513,6 +6516,8 @@ static void *asyncWrite(void *sarg) {
   threadInfo *pThreadInfo = (threadInfo *)sarg;
   SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
 
+  setThreadName("asyncWrite");
+
   pThreadInfo->st = 0;
   pThreadInfo->et = 0;
   pThreadInfo->lastTs = pThreadInfo->start_time;
@@ -6911,6 +6916,7 @@ static void *readTable(void *sarg) {
 #if 1
   threadInfo *pThreadInfo = (threadInfo *)sarg;
   TAOS *taos = pThreadInfo->taos;
+  setThreadName("readTable");
   char command[BUFFER_SIZE] = "\0";
   uint64_t sTime = pThreadInfo->start_time;
   char *tb_prefix = pThreadInfo->tb_prefix;
@@ -6983,6 +6989,7 @@ static void *readMetric(void *sarg) {
 #if 1
   threadInfo *pThreadInfo = (threadInfo *)sarg;
   TAOS *taos = pThreadInfo->taos;
+  setThreadName("readMetric");
   char command[BUFFER_SIZE] = "\0";
   FILE *fp = fopen(pThreadInfo->filePath, "a");
   if (NULL == fp) {
@@ -7159,6 +7166,8 @@ static int insertTestProcess() {
 static void *specifiedTableQuery(void *sarg) {
   threadInfo *pThreadInfo = (threadInfo *)sarg;
 
+  setThreadName("specTableQuery");
+
   if (pThreadInfo->taos == NULL) {
     TAOS * taos = NULL;
     taos = taos_connect(g_queryInfo.host,
@@ -7258,6 +7267,8 @@ static void *superTableQuery(void *sarg) {
   char sqlstr[MAX_QUERY_SQL_LENGTH];
   threadInfo *pThreadInfo = (threadInfo *)sarg;
 
+  setThreadName("superTableQuery");
+
   if (pThreadInfo->taos == NULL) {
     TAOS * taos = NULL;
     taos = taos_connect(g_queryInfo.host,
@@ -7560,6 +7571,8 @@ static void *superSubscribe(void *sarg) {
     TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT] = {0};
     uint64_t tsubSeq;
 
+    setThreadName("superSub");
+
     if (pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
         errorPrint("The table number(%"PRId64") of the thread is more than max query sql count: %d\n",
                 pThreadInfo->ntables, MAX_QUERY_SQL_COUNT);
@@ -7706,6 +7719,8 @@ static void *specifiedSubscribe(void *sarg) {
   threadInfo *pThreadInfo = (threadInfo *)sarg;
 //  TAOS_SUB*  tsub = NULL;
 
+  setThreadName("specSub");
+
   if (pThreadInfo->taos == NULL) {
     pThreadInfo->taos = taos_connect(g_queryInfo.host,
           g_queryInfo.user,
diff --git a/src/kit/taosdump/taosdump.c b/src/kit/taosdump/taosdump.c
index 98521d842064c8fe1b07478810c15d870ceaadf5..e5501b4366f24fdee9ace153e59b4a60dc67455f 100644
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -1474,6 +1474,8 @@ static void* taosDumpOutWorkThreadFp(void *arg)
     STableRecord    tableRecord;
     int fd;
 
+    setThreadName("dumpOutWorkThrd");
+
     char tmpBuf[4096] = {0};
     sprintf(tmpBuf, ".tables.tmp.%d", pThread->threadIndex);
     fd = open(tmpBuf, O_RDWR | O_CREAT, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH);
@@ -2571,6 +2573,8 @@ static int taosDumpInOneFile(TAOS* taos, FILE* fp, char* fcharset,
 static void* taosDumpInWorkThreadFp(void *arg)
 {
     SThreadParaObj *pThread = (SThreadParaObj*)arg;
+    setThreadName("dumpInWorkThrd");
+
     for (int32_t f = 0; f < g_tsSqlFileNum; ++f) {
         if (f % pThread->totalThreads == pThread->threadIndex) {
             char *SQLFileName = g_tsDumpInSqlFiles[f];
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 897c3a2f0f6c144a7975c73fd2ad57342dc59f7f..7644f4d7339251037fbe244b17e5af1fa9af0484 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -1113,6 +1113,7 @@ static void *sdbWorkerFp(void *pWorker) {
   void *   unUsed;
 
   taosBlockSIGPIPE();
+  setThreadName("sdbWorker");
 
   while (1) {
     int32_t numOfMsgs = taosReadAllQitemsFromQset(tsSdbWQset, tsSdbWQall, &unUsed);
diff --git a/src/os/inc/osDef.h b/src/os/inc/osDef.h
index 9176da5b8ee5216ee07bf7d6706c8acbb5ece299..54a4f98254039761d3486267ab2081ac77444489 100644
--- a/src/os/inc/osDef.h
+++ b/src/os/inc/osDef.h
@@ -210,6 +210,25 @@ extern "C" {
   #define PRIzu "zu"  
 #endif
 
+
+#if defined(_TD_LINUX_64) || defined(_TD_LINUX_32) || defined(_TD_MIPS_64)  || defined(_TD_ARM_32) || defined(_TD_ARM_64)  || defined(_TD_DARWIN_64)
+  #if defined(_TD_DARWIN_64)
+    // MacOS
+    #if !defined(_GNU_SOURCE)
+      #define setThreadName(name) do { pthread_setname_np((name)); } while (0)
+    #else
+      // pthread_setname_np not defined
+      #define setThreadName(name)
+    #endif
+  #else
+    // Linux, length of name must <= 16 (the last '\0' included)
+    #define setThreadName(name) do { prctl(PR_SET_NAME, (name)); } while (0)
+  #endif
+#else
+  // Windows
+  #define setThreadName(name)
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/os/inc/osInc.h b/src/os/inc/osInc.h
index 340ff34635d6a76781d9deb5c6012f0e2c5ffa13..9b78110833e73274f82d051cbaa6fd35c90f2a08 100644
--- a/src/os/inc/osInc.h
+++ b/src/os/inc/osInc.h
@@ -85,6 +85,7 @@ extern "C" {
     #include <sys/eventfd.h>
     #include <sys/resource.h>
     #include <sys/sendfile.h>
+    #include <sys/prctl.h>
 
     #if !(defined(_ALPINE))
       #include <error.h>
diff --git a/src/os/src/darwin/dwSemaphore.c b/src/os/src/darwin/dwSemaphore.c
index 898410647ad6e23428656f6f820504126268af07..25cb28cff1b6f9c83cab43faf68641717450c0ea 100644
--- a/src/os/src/darwin/dwSemaphore.c
+++ b/src/os/src/darwin/dwSemaphore.c
@@ -41,6 +41,8 @@ static semaphore_t               sem_exit;
 
 static void* sem_thread_routine(void *arg) {
   (void)arg;
+  setThreadName("sem_thrd");
+
   sem_port = mach_task_self();
   kern_return_t ret = semaphore_create(sem_port, &sem_exit, SYNC_POLICY_FIFO, 0);
   if (ret != KERN_SUCCESS) {
diff --git a/src/os/src/darwin/dwTimer.c b/src/os/src/darwin/dwTimer.c
index ee1becc91af5237296bb2a562982b33cc5c78f10..d395a7f53f2baa9a806ab8cbe96253deb7334f6e 100644
--- a/src/os/src/darwin/dwTimer.c
+++ b/src/os/src/darwin/dwTimer.c
@@ -32,6 +32,7 @@ static volatile int  timer_stop = 0;
 
 static void* timer_routine(void *arg) {
   (void)arg;
+  setThreadName("timer");
 
   int r = 0;
   struct timespec to = {0};
diff --git a/src/os/src/detail/osTimer.c b/src/os/src/detail/osTimer.c
index b054f08c7842ed405f818b26be6040c543fa7644..c381b3e825f508b17ec0d6a053a574957c5dc365 100644
--- a/src/os/src/detail/osTimer.c
+++ b/src/os/src/detail/osTimer.c
@@ -38,6 +38,8 @@ static void *taosProcessAlarmSignal(void *tharg) {
 
   struct sigevent sevent = {{0}};
 
+  setThreadName("alarmSignal");
+
   #ifdef _ALPINE
     sevent.sigev_notify = SIGEV_THREAD;
     sevent.sigev_value.sival_int = syscall(__NR_gettid);
diff --git a/src/plugins/http/src/httpQueue.c b/src/plugins/http/src/httpQueue.c
index 7f7ce404600b96b0efe8385ea0aed7be412a6ba0..677ab0c91d4a6e446eae6dd5213788166b2c40bf 100644
--- a/src/plugins/http/src/httpQueue.c
+++ b/src/plugins/http/src/httpQueue.c
@@ -70,6 +70,8 @@ static void *httpProcessResultQueue(void *param) {
   int32_t      type;
   void *       unUsed;
 
+  setThreadName("httpResultQ");
+
   while (1) {
     if (taosReadQitemFromQset(tsHttpQset, &type, (void **)&pMsg, &unUsed) == 0) {
       httpDebug("qset:%p, http queue got no message from qset, exiting", tsHttpQset);
diff --git a/src/plugins/http/src/httpServer.c b/src/plugins/http/src/httpServer.c
index 9d98d3f11300fa8143f9a32718c6a865b9a59a97..f02859f165499b0c69b095599dd47890e644c604 100644
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
@@ -117,6 +117,7 @@ static void httpProcessHttpData(void *param) {
   int32_t      fdNum;
 
   taosSetMaskSIGPIPE();
+  setThreadName("httpData");
 
   while (1) {
     struct epoll_event events[HTTP_MAX_EVENTS];
@@ -208,6 +209,7 @@ static void *httpAcceptHttpConnection(void *arg) {
   int32_t            totalFds = 0;
 
   taosSetMaskSIGPIPE();
+  setThreadName("httpAcceptConn");
 
   pServer->fd = taosOpenTcpServerSocket(pServer->serverIp, pServer->serverPort);
 
diff --git a/src/plugins/monitor/src/monMain.c b/src/plugins/monitor/src/monMain.c
index 2c4a0c1a4c56e560a9ffe5ec007cc51f9d7f9e24..960a097f5d99bb430f888d01960a879e80456d31 100644
--- a/src/plugins/monitor/src/monMain.c
+++ b/src/plugins/monitor/src/monMain.c
@@ -114,6 +114,7 @@ int32_t monStartSystem() {
 
 static void *monThreadFunc(void *param) {
   monDebug("starting to initialize monitor module ...");
+  setThreadName("monThrd");
 
   while (1) {
     static int32_t accessTimes = 0;
diff --git a/src/plugins/mqtt/src/mqttSystem.c b/src/plugins/mqtt/src/mqttSystem.c
index eacc3b1f74cdfc0d00bb53a38beb8c85b164e200..e0f2f393bb10706daadca35715d7e0ae68d7c436 100644
--- a/src/plugins/mqtt/src/mqttSystem.c
+++ b/src/plugins/mqtt/src/mqttSystem.c
@@ -100,6 +100,8 @@ void mqttPublishCallback(void** unused, struct mqtt_response_publish* published)
 }
 
 void* mqttClientRefresher(void* client) {
+  setThreadName("mqttCliRefresh");
+
   while (tsMqttIsRuning) {
     mqtt_sync((struct mqtt_client*)client);
     taosMsleep(100);
@@ -141,4 +143,4 @@ void mqttReconnectClient(struct mqtt_client* client, void** unused) {
   mqtt_reinit(client, sockfd, tsMqttStatus.sendbuf, tsMqttStatus.sendbufsz, tsMqttStatus.recvbuf, tsMqttStatus.recvbufsz);
   mqtt_connect(client, tsMqttClientId, NULL, NULL, 0, tsMqttUser, tsMqttPass, MQTT_CONNECT_CLEAN_SESSION, 400);
   mqtt_subscribe(client, tsMqttTopic, 0);
-}
\ No newline at end of file
+}
diff --git a/src/rpc/src/rpcTcp.c b/src/rpc/src/rpcTcp.c
index 029629eff0e10f5bc8812f3df8998b24a507931d..e9feeef9d339a5b1a96e41fd35fb6c62e13ed94b 100644
--- a/src/rpc/src/rpcTcp.c
+++ b/src/rpc/src/rpcTcp.c
@@ -242,6 +242,7 @@ static void *taosAcceptTcpConnection(void *arg) {
 
   pServerObj = (SServerObj *)arg;
   tDebug("%s TCP server is ready, ip:0x%x:%hu", pServerObj->label, pServerObj->ip, pServerObj->port);
+  setThreadName("acceptTcpConn");
 
   while (1) {
     socklen_t addrlen = sizeof(caddr);
@@ -528,6 +529,11 @@ static void *taosProcessTcpData(void *param) {
   SFdObj            *pFdObj;
   struct epoll_event events[maxEvents];
   SRecvInfo          recvInfo;
+  char               name[16];
+
+  memset(name, 0, sizeof(name));
+  snprintf(name, 16, "%s-tcpData", pThreadObj->label);
+  setThreadName(name);
 
   while (1) {
     int fdNum = epoll_wait(pThreadObj->pollFd, events, maxEvents, TAOS_EPOLL_WAIT_TIME);
diff --git a/src/rpc/src/rpcUdp.c b/src/rpc/src/rpcUdp.c
index 7a46dbe5c3e1238da93043f8dc97047f84ff72e8..086a390cb8ea2a95f576cb1bff81dfc79769863a 100644
--- a/src/rpc/src/rpcUdp.c
+++ b/src/rpc/src/rpcUdp.c
@@ -195,6 +195,8 @@ static void *taosRecvUdpData(void *param) {
   tDebug("%s UDP thread is created, index:%d", pConn->label, pConn->index);
   char *msg = pConn->buffer;
 
+  setThreadName("recvUdpData");
+
   while (1) {
     dataLen = recvfrom(pConn->fd, pConn->buffer, RPC_MAX_UDP_SIZE, 0, (struct sockaddr *)&sourceAdd, &addLen);
     if (dataLen <= 0) {
diff --git a/src/rpc/test/rclient.c b/src/rpc/test/rclient.c
index faa6d40da398045e43dba3bbdbaf9ef6c7ccb1ff..de30114bd1c7fa9687a6d75bca3d7158137e29e4 100644
--- a/src/rpc/test/rclient.c
+++ b/src/rpc/test/rclient.c
@@ -47,6 +47,8 @@ static int tcount = 0;
 static void *sendRequest(void *param) {
   SInfo  *pInfo = (SInfo *)param;
   SRpcMsg rpcMsg = {0}; 
+
+  setThreadName("sendCliReq");
   
   tDebug("thread:%d, start to send request", pInfo->index);
 
diff --git a/src/rpc/test/rsclient.c b/src/rpc/test/rsclient.c
index a152d8e4a51502357530267acb924c74426c9509..3e94a56efb3494ac5fe1942245abd0bad8815ee7 100644
--- a/src/rpc/test/rsclient.c
+++ b/src/rpc/test/rsclient.c
@@ -39,8 +39,10 @@ static int terror = 0;
 
 static void *sendRequest(void *param) {
   SInfo  *pInfo = (SInfo *)param;
-  SRpcMsg rpcMsg, rspMsg; 
+  SRpcMsg rpcMsg, rspMsg;
   
+  setThreadName("sendSrvReq");
+ 
   tDebug("thread:%d, start to send request", pInfo->index);
 
   while ( pInfo->numOfReqs == 0 || pInfo->num < pInfo->numOfReqs) {
diff --git a/src/sync/src/syncRestore.c b/src/sync/src/syncRestore.c
index c0d66316cd5b802ddcaddf1015d4ceca1aa3b2c5..bf9d5201a062e048365c2887b7b6a6d70b40547f 100644
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
@@ -263,6 +263,7 @@ static int32_t syncRestoreDataStepByStep(SSyncPeer *pPeer) {
 }
 
 void *syncRestoreData(void *param) {
+  setThreadName("syncRestoreData");
   int64_t    rid = (int64_t)param;
   SSyncPeer *pPeer = syncAcquirePeer(rid);
   if (pPeer == NULL) {
diff --git a/src/sync/src/syncRetrieve.c b/src/sync/src/syncRetrieve.c
index c86ab8549974712658ad3d381c4141427c000762..89fdda0686ffc6d7d5b372def92e48c6cf06c2ab 100644
--- a/src/sync/src/syncRetrieve.c
+++ b/src/sync/src/syncRetrieve.c
@@ -415,6 +415,7 @@ static int32_t syncRetrieveDataStepByStep(SSyncPeer *pPeer) {
 }
 
 void *syncRetrieveData(void *param) {
+  setThreadName("syncRetrievData");
   int64_t    rid = (int64_t)param;
   SSyncPeer *pPeer = syncAcquirePeer(rid);
   if (pPeer == NULL) {
diff --git a/src/sync/src/syncTcp.c b/src/sync/src/syncTcp.c
index 3ad9e9bba01eb861c48fa121b154af3e7838dda0..698245f9e408281e2a7c41da2d6228a1ec12217d 100644
--- a/src/sync/src/syncTcp.c
+++ b/src/sync/src/syncTcp.c
@@ -195,6 +195,8 @@ static void *syncProcessTcpData(void *param) {
   SConnObj *  pConn = NULL;
   struct epoll_event events[maxEvents];
 
+  setThreadName("syncTcpData");
+
   void *buffer = malloc(pInfo->bufferSize);
   taosBlockSIGPIPE();
 
@@ -257,6 +259,7 @@ static void *syncAcceptPeerTcpConnection(void *argv) {
   SPoolInfo *pInfo = &pPool->info;
 
   taosBlockSIGPIPE();
+  setThreadName("acceptTcpConn");
 
   while (1) {
     struct sockaddr_in clientAddr;
diff --git a/src/sync/test/syncClient.c b/src/sync/test/syncClient.c
index 23ea54ee0c19b6ad2f93d7577d8d711874b10968..303d2376effffa3a3b2dc01580352a43aeaac9d8 100644
--- a/src/sync/test/syncClient.c
+++ b/src/sync/test/syncClient.c
@@ -48,6 +48,8 @@ void *sendRequest(void *param) {
   SInfo * pInfo = (SInfo *)param;
   SRpcMsg rpcMsg = {0};
 
+  setThreadName("sendCliReq");
+
   uDebug("thread:%d, start to send request", pInfo->index);
 
   while (pInfo->numOfReqs == 0 || pInfo->num < pInfo->numOfReqs) {
diff --git a/src/sync/test/syncServer.c b/src/sync/test/syncServer.c
index eeaa6a08c2e47d103b62d6023dde74341585f65f..a3d06966488b95a561c9bc688b49f7ceceb87248 100644
--- a/src/sync/test/syncServer.c
+++ b/src/sync/test/syncServer.c
@@ -178,6 +178,8 @@ void *processWriteQueue(void *param) {
   int   type;
   void *item;
 
+  setThreadName("writeQ");
+
   while (1) {
     int ret = taosReadQitem(qhandle, &type, &item);
     if (ret <= 0) {
diff --git a/src/tsdb/src/tsdbCommitQueue.c b/src/tsdb/src/tsdbCommitQueue.c
index e25014bc1e8f2456eece3d517096cfee66886800..e45ac05e979b119ee7995cf845a6f242a9953cb3 100644
--- a/src/tsdb/src/tsdbCommitQueue.c
+++ b/src/tsdb/src/tsdbCommitQueue.c
@@ -158,6 +158,8 @@ static void *tsdbLoopCommit(void *arg) {
   STsdbRepo *   pRepo = NULL;
   TSDB_REQ_T    req;
 
+  setThreadName("tsdbCommit");
+
   while (true) {
     pthread_mutex_lock(&(pQueue->lock));
 
@@ -208,4 +210,4 @@ void tsdbDecCommitRef(int vgId) {
   int refCount = atomic_sub_fetch_32(&tsCommitQueue.refCount, 1);
   pthread_cond_broadcast(&(tsCommitQueue.queueNotEmpty));
   tsdbDebug("vgId:%d, dec commit queue ref to %d", vgId, refCount);
-}
\ No newline at end of file
+}
diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index 569f9b01bda6d3a8cf5de6ba4b089e7bab49ca9f..c6ee79e101d4b79aacce553ccb8e7e171f23aef6 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -656,6 +656,8 @@ void* taosCacheTimedRefresh(void *handle) {
     return NULL;
   }
 
+  setThreadName("cacheTimedRefre");
+
   const int32_t SLEEP_DURATION = 500; //500 ms
   int64_t totalTick = pCacheObj->refreshTime / SLEEP_DURATION;
 
diff --git a/src/util/src/tlog.c b/src/util/src/tlog.c
index 45ff14ffa4adcd018cbf7a7d69b8644582855ab3..88f57e8ac24cd207fc44f581564f45a9c33c348e 100644
--- a/src/util/src/tlog.c
+++ b/src/util/src/tlog.c
@@ -178,6 +178,8 @@ static void *taosThreadToOpenNewFile(void *param) {
   char keepName[LOG_FILE_NAME_LEN + 20];
   sprintf(keepName, "%s.%d", tsLogObj.logName, tsLogObj.flag);
 
+  setThreadName("openNewFile");
+
   tsLogObj.flag ^= 1;
   tsLogObj.lines = 0;
   char name[LOG_FILE_NAME_LEN + 20];
@@ -687,6 +689,8 @@ static void taosWriteLog(SLogBuff *tLogBuff) {
 
 static void *taosAsyncOutputLog(void *param) {
   SLogBuff *tLogBuff = (SLogBuff *)param;
+
+  setThreadName("asyncOutputLog");
   
   while (1) {
     //tsem_wait(&(tLogBuff->buffNotEmpty));
diff --git a/src/util/src/tnettest.c b/src/util/src/tnettest.c
index 318a2d48609a129bcf6094455ff2a7cc8f7c0467..0bab7b7e6623ebaa5de6d6511fa1c43719372ef5 100644
--- a/src/util/src/tnettest.c
+++ b/src/util/src/tnettest.c
@@ -50,7 +50,9 @@ static void *taosNetBindUdpPort(void *sarg) {
   struct sockaddr_in server_addr;
   struct sockaddr_in clientAddr;
 
-   if ((serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+  setThreadName("netBindUdpPort");
+
+  if ((serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
     uError("failed to create UDP socket since %s", strerror(errno));
     return NULL;
   }
@@ -106,13 +108,15 @@ static void *taosNetBindTcpPort(void *sarg) {
   struct sockaddr_in server_addr;
   struct sockaddr_in clientAddr;
 
- STestInfo *pinfo = sarg;
+  STestInfo *pinfo = sarg;
   int32_t    port = pinfo->port;
   SOCKET     serverSocket;
   int32_t    addr_len = sizeof(clientAddr);
   SOCKET     client;
   char       buffer[BUFFER_SIZE];
 
+  setThreadName("netBindTcpPort");
+
   if ((serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
     uError("failed to create TCP socket since %s", strerror(errno));
     return NULL;
diff --git a/src/util/src/tnote.c b/src/util/src/tnote.c
index c6d49dfb3d8242bdf697b3212fde479f01f8bcd9..b691abc5b9f6f828edcc46ec3a5989baa083f443 100644
--- a/src/util/src/tnote.c
+++ b/src/util/src/tnote.c
@@ -84,6 +84,8 @@ static void *taosThreadToOpenNewNote(void *param) {
   char      name[NOTE_FILE_NAME_LEN * 2];
   SNoteObj *pNote = (SNoteObj *)param;
 
+  setThreadName("openNewNote");
+
   pNote->flag ^= 1;
   pNote->lines = 0;
   sprintf(name, "%s.%d", pNote->name, pNote->flag);
diff --git a/src/util/src/tsched.c b/src/util/src/tsched.c
index 16142470c95678b8663f3bd437357dcdb22635a5..3d3dfd989926c4acf8b32d8c7df724cb2d1ac079 100644
--- a/src/util/src/tsched.c
+++ b/src/util/src/tsched.c
@@ -122,6 +122,8 @@ void *taosProcessSchedQueue(void *scheduler) {
   SSchedQueue *pSched = (SSchedQueue *)scheduler;
   int ret = 0;
 
+  setThreadName("schedQ");
+
   while (1) {
     if ((ret = tsem_wait(&pSched->fullSem)) != 0) {
       uFatal("wait %s fullSem failed(%s)", pSched->label, strerror(errno));
@@ -234,4 +236,4 @@ void taosDumpSchedulerStatus(void *qhandle, void *tmrId) {
   }
   
   taosTmrReset(taosDumpSchedulerStatus, DUMP_SCHEDULER_TIME_WINDOW, pSched, pSched->pTmrCtrl, &pSched->pTimer);
-}
\ No newline at end of file
+}
diff --git a/src/util/tests/trefTest.c b/src/util/tests/trefTest.c
index 454860410b4dd0c3fdf65c4b7fd7950a1a7d4446..d89ccb6879c36422d8ca7297a71ba8fd1fef14de 100644
--- a/src/util/tests/trefTest.c
+++ b/src/util/tests/trefTest.c
@@ -36,6 +36,8 @@ void *addRef(void *param) {
   int id;
   int64_t rid;
 
+  setThreadName("addRef");
+
   for (int i=0; i < pSpace->steps; ++i) {
     printf("a");
     id = random() % pSpace->refNum; 
@@ -54,6 +56,8 @@ void *removeRef(void *param) {
   int id;
   int64_t rid;
 
+  setThreadName("removeRef");
+
   for (int i=0; i < pSpace->steps; ++i) {
     printf("d");
     id = random() % pSpace->refNum; 
@@ -73,6 +77,8 @@ void *acquireRelease(void *param) {
   int id;
   int64_t rid;
 
+  setThreadName("acquireRelease");
+
   for (int i=0; i < pSpace->steps; ++i) {
     printf("a");
     
@@ -94,6 +100,8 @@ void myfree(void *p) {
 void *openRefSpace(void *param) {
   SRefSpace *pSpace = (SRefSpace *)param;
 
+  setThreadName("openRefSpace");
+
   printf("c");
   pSpace->rsetId = taosOpenRef(50, myfree);
 
diff --git a/src/vnode/src/vnodeBackup.c b/src/vnode/src/vnodeBackup.c
index a0a975be2bcfbb2c945a72adecbf47f9cf404b40..801af42e0e6869944ec60169b0662131be787cba 100644
--- a/src/vnode/src/vnodeBackup.c
+++ b/src/vnode/src/vnodeBackup.c
@@ -61,6 +61,8 @@ static void vnodeProcessBackupMsg(SVBackupMsg *pMsg) {
 }
 
 static void *vnodeBackupFunc(void *param) {
+  setThreadName("vnodeBackup");
+
   while (1) {
     SVBackupMsg *pMsg = NULL;
     if (taosReadQitemFromQset(tsVBackupQset, NULL, (void **)&pMsg, NULL) == 0) {
diff --git a/src/vnode/src/vnodeWorker.c b/src/vnode/src/vnodeWorker.c
index 6fb79d10feef74d88e04368c5607d39e7d70f6f2..e94c99cbea99139a21fb7fb64c729a12d3091349 100644
--- a/src/vnode/src/vnodeWorker.c
+++ b/src/vnode/src/vnodeWorker.c
@@ -188,6 +188,8 @@ static void vnodeProcessMWorkerMsg(SVMWorkerMsg *pMsg) {
 }
 
 static void *vnodeMWorkerFunc(void *param) {
+  setThreadName("vnodeMWorker");
+
   while (1) {
     SVMWorkerMsg *pMsg = NULL;
     if (taosReadQitemFromQset(tsVMWorkerQset, NULL, (void **)&pMsg, NULL) == 0) {
diff --git a/src/wal/src/walMgmt.c b/src/wal/src/walMgmt.c
index 9bd5cdf1750b106df9eed8c033c1adff91d9b8e5..45f65b2c2fc9ae5412f471805a3244644e590638 100644
--- a/src/wal/src/walMgmt.c
+++ b/src/wal/src/walMgmt.c
@@ -192,6 +192,7 @@ static void walFsyncAll() {
 
 static void *walThreadFunc(void *param) {
   int stop = 0;
+  setThreadName("walThrd");
   while (1) {
     walUpdateSeq();
     walFsyncAll();