diff --git a/README.md b/README.md
index 145e065b03d0f92567668f291431bf4298c24325..980963ebdf776d2b4d23c0e23494d848eb4be7fe 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ cpp\_tbox，全称: C++ Treasure Box，C++开发百宝箱，是基于事件的
 
 | 库名 | 依赖模块 | 说明 | 安装方法 |
 |:----:|:--------:|:----:|:--------:|
-| googletest | 所有模块 | 单元测试要用 | apt install google-mock |
+| googletest | 所有模块 | 单元测试用，如果不进行单元测试可忽略 | apt install google-mock |
 | libevent | event | 在event/config.mk中开启了WITH\_LIBEVENT时依赖 | apt install libevent-dev |
 | libev | event | 在event/config.mk中开启了WITH\_LIBEV时依赖 | apt install libev-dev |
 | mosquitto | mqtt | MQTT client库 | apt install libmosquitto-dev |
@@ -39,16 +39,7 @@ cpp\_tbox，全称: C++ Treasure Box，C++开发百宝箱，是基于事件的
 
 #### 模块间依赖
 
-- base --> None
-- util --> base
-- event --> base, util
-- eventx --> event
-- network --> event
-- coroutine --> event
-- mqtt --> event
-- terminal --> network
-- main --> eventx, network
-- sample --> main
+![](http://assets.processon.com/chart_image/6227efafe401fd18bcfc83e8.png)
 
 #### 模块裁减
 
diff --git a/config.mk b/config.mk
index ddec6b7c576d2e7e5b27316b7bfb124443af3994..577bc36dc2cefde2f7cd30e8875f2cb450e1b148 100644
--- a/config.mk
+++ b/config.mk
@@ -1,11 +1,11 @@
 app_y += base
-app_y += util
 app_y += event
 app_y += eventx
 app_y += network
 app_y += coroutine
 app_y += mqtt
 app_y += log2file
+app_y += util
 app_y += terminal
 app_y += main
 app_y += sample
diff --git a/event/common_loop.h b/event/common_loop.h
index c29982acbac608b9754a4a83c3b58607bdc6e94f..9b06ba36ec1fc99bed7407abc4d5760d63201675 100644
--- a/event/common_loop.h
+++ b/event/common_loop.h
@@ -19,27 +19,27 @@ namespace event {
 
 class CommonLoop : public Loop {
   public:
-    ~CommonLoop() override;
+    virtual ~CommonLoop() override;
 
   public:
-    bool isInLoopThread() override;
-    bool isRunning() const override;
+    virtual bool isInLoopThread() override;
+    virtual bool isRunning() const override;
 
-    void runInLoop(const Func &func) override;
-    void runNext(const Func &func) override;
-    void run(const Func &func) override;
+    virtual void runInLoop(const Func &func) override;
+    virtual void runNext(const Func &func) override;
+    virtual void run(const Func &func) override;
 
-    void setStatEnable(bool enable) override;
-    bool isStatEnabled() const override;
-    Stat getStat() const override;
-    void resetStat() override;
+    virtual void setStatEnable(bool enable) override;
+    virtual bool isStatEnabled() const override;
+    virtual Stat getStat() const override;
+    virtual void resetStat() override;
 
   public:
     void beginEventProcess();
     void endEventProcess();
 
     //! 信号处理相关
-    SignalEvent* newSignalEvent() override;
+    virtual SignalEvent* newSignalEvent() override;
     bool subscribeSignal(int signal_num, SignalSubscribuer *who);
     bool unsubscribeSignal(int signal_num, SignalSubscribuer *who);
     static void HandleSignal(int signo);
diff --git a/event/engins/epoll/fd_event.h b/event/engins/epoll/fd_event.h
index ffada8015d91f515ae8725e185c820541c316424..7d8a2de5bae75e73b90737ac9b98932879848dbb 100644
--- a/event/engins/epoll/fd_event.h
+++ b/event/engins/epoll/fd_event.h
@@ -14,17 +14,17 @@ struct EpollFdSharedData;
 class EpollFdEvent : public FdEvent {
   public:
     explicit EpollFdEvent(EpollLoop *wp_loop);
-    ~EpollFdEvent() override;
+    virtual ~EpollFdEvent() override;
 
   public:
-    bool initialize(int fd, short events, Mode mode) override;
-    void setCallback(const CallbackFunc &cb) override { cb_ = cb; }
+    virtual bool initialize(int fd, short events, Mode mode) override;
+    virtual void setCallback(const CallbackFunc &cb) override { cb_ = cb; }
 
-    bool isEnabled() const override{ return is_enabled_; }
-    bool enable() override;
-    bool disable() override;
+    virtual bool isEnabled() const override{ return is_enabled_; }
+    virtual bool enable() override;
+    virtual bool disable() override;
 
-    Loop* getLoop() const override;
+    virtual Loop* getLoop() const override;
 
   public:
     static void OnEventCallback(int fd, uint32_t events, void *obj);
diff --git a/event/engins/epoll/loop.cpp b/event/engins/epoll/loop.cpp
index 8c0b3144c5a396ab9522e757ecc4c04eff8d984a..196cc447bf5c5cabe1812539edebe994e66b63f9 100644
--- a/event/engins/epoll/loop.cpp
+++ b/event/engins/epoll/loop.cpp
@@ -121,13 +121,7 @@ void EpollLoop::runLoop(Mode mode)
         /// If the receiver array size is full, increase its size with 1.5 times.
         if (fds >= max_loop_entries_) {
             max_loop_entries_ = (max_loop_entries_ + max_loop_entries_ / 2);
-#if 0
-            std::vector<struct epoll_event> temp_events;
-            temp_events.resize(max_loop_entries_);
-            events.swap(temp_events);
-#else
             events.resize(max_loop_entries_);
-#endif
         }
 
     } while (keep_running_);
diff --git a/event/engins/epoll/loop.h b/event/engins/epoll/loop.h
index c62f1e6a26a7236cf85c83bd765cae55ce4e4a1d..c63b48cc8ac61ebc4f646022457c191fa4860706 100644
--- a/event/engins/epoll/loop.h
+++ b/event/engins/epoll/loop.h
@@ -20,14 +20,14 @@ struct EpollFdSharedData;
 class EpollLoop : public CommonLoop {
   public:
     explicit EpollLoop();
-    virtual ~EpollLoop();
+    virtual ~EpollLoop() override;
 
   public:
-    virtual void runLoop(Mode mode);
-    virtual void exitLoop(const std::chrono::milliseconds &wait_time);
+    virtual void runLoop(Mode mode) override;
+    virtual void exitLoop(const std::chrono::milliseconds &wait_time) override;
 
-    virtual FdEvent* newFdEvent();
-    virtual TimerEvent* newTimerEvent();
+    virtual FdEvent* newFdEvent() override;
+    virtual TimerEvent* newTimerEvent() override;
 
   public:
     inline int epollFd() const { return epoll_fd_; }
@@ -61,11 +61,11 @@ class EpollLoop : public CommonLoop {
     };
 
   private:
-    int  max_loop_entries_{ DEFAULT_MAX_LOOP_ENTRIES };
-    int  epoll_fd_{ -1 };
-    bool keep_running_{ true };
+    int  max_loop_entries_ = DEFAULT_MAX_LOOP_ENTRIES;
+    int  epoll_fd_ = -1;
+    bool keep_running_ = true;
 
-    TimerEvent *sp_exit_timer_{ nullptr };
+    TimerEvent *sp_exit_timer_ = nullptr;
 
     cabinet::Cabinet<Timer> timer_cabinet_;
     std::vector<Timer*>     timer_min_heap_;
diff --git a/event/engins/epoll/timer_event.h b/event/engins/epoll/timer_event.h
index d84acdc5f96737d01b614a9cd7e311ed5aaba54b..f0965d022ed7d587c9613d79e318a13e39f8585e 100644
--- a/event/engins/epoll/timer_event.h
+++ b/event/engins/epoll/timer_event.h
@@ -12,31 +12,31 @@ class EpollLoop;
 class EpollTimerEvent : public TimerEvent {
   public:
     explicit EpollTimerEvent(EpollLoop *wp_loop);
-    virtual ~EpollTimerEvent();
+    virtual ~EpollTimerEvent() override;
 
   public:
-    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode);
-    virtual void setCallback(const CallbackFunc &cb);
+    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode) override;
+    virtual void setCallback(const CallbackFunc &cb) override;
 
-    virtual bool isEnabled() const;
-    virtual bool enable();
-    virtual bool disable();
+    virtual bool isEnabled() const override;
+    virtual bool enable() override;
+    virtual bool disable() override;
 
-    virtual Loop* getLoop() const;
+    virtual Loop* getLoop() const override;
 
   protected:
     void onEvent();
 
   private:
     EpollLoop *wp_loop_;
-    bool is_inited_{ false };
-    bool is_enabled_{ false };
+    bool is_inited_  = false;
+    bool is_enabled_ = false;
 
-    std::chrono::milliseconds interval_{ 0 };
-    Mode mode_{ Mode::kOneshot };
+    std::chrono::milliseconds interval_;
+    Mode mode_ = Mode::kOneshot;
 
-    CallbackFunc cb_{ nullptr };
-    int cb_level_{ 0 };
+    CallbackFunc cb_;
+    int cb_level_ = 0;
 
     cabinet::Token token_;
 };
diff --git a/event/engins/libev/fd_event.cpp b/event/engins/libev/fd_event.cpp
index d486b3cfc71bce0ebb31c55f084da3018591003d..ffb73cb4dbe1c6d414e82704767609ff8f23304c 100644
--- a/event/engins/libev/fd_event.cpp
+++ b/event/engins/libev/fd_event.cpp
@@ -9,10 +9,7 @@ namespace tbox {
 namespace event {
 
 LibevFdEvent::LibevFdEvent(LibevLoop *wp_loop) :
-    wp_loop_(wp_loop),
-    is_inited_(false),
-    is_stop_after_trigger_(false),
-    cb_level_(0)
+    wp_loop_(wp_loop)
 {
     memset(&io_ev_, 0, sizeof(io_ev_));
 }
diff --git a/event/engins/libev/fd_event.h b/event/engins/libev/fd_event.h
index e4ce0490bc8040eba52b312bf2f42ea73b973703..0f91fa5da5c9ecd91afe80e8a9372280cfcef232 100644
--- a/event/engins/libev/fd_event.h
+++ b/event/engins/libev/fd_event.h
@@ -32,10 +32,10 @@ class LibevFdEvent : public FdEvent {
   private:
     LibevLoop *wp_loop_;
     ev_io io_ev_;
-    bool is_inited_;
-    bool is_stop_after_trigger_;
+    bool is_inited_ = false;
+    bool is_stop_after_trigger_ = false;
     CallbackFunc cb_;
-    int cb_level_;
+    int cb_level_ = 0;
 };
 
 }
diff --git a/event/engins/libev/loop.cpp b/event/engins/libev/loop.cpp
index f7a6e63f6e26e39a466504dcf309a15f4143b753..b7c9b1ec90fe7d4d9bdf3b982b4e50a18c9c1608 100644
--- a/event/engins/libev/loop.cpp
+++ b/event/engins/libev/loop.cpp
@@ -9,8 +9,7 @@ namespace tbox {
 namespace event {
 
 LibevLoop::LibevLoop() :
-    sp_ev_loop_(ev_loop_new()),
-    sp_exit_timer_(nullptr)
+    sp_ev_loop_(ev_loop_new())
 { }
 
 LibevLoop::~LibevLoop()
diff --git a/event/engins/libev/loop.h b/event/engins/libev/loop.h
index 9087bd2a10d368d7f8042d8ad5eb64640dbfaa77..8909d3904dc893b17783d304bd1c07bdea99f11a 100644
--- a/event/engins/libev/loop.h
+++ b/event/engins/libev/loop.h
@@ -28,7 +28,7 @@ class LibevLoop : public CommonLoop {
 
   private:
     struct ev_loop *sp_ev_loop_;
-    TimerEvent *sp_exit_timer_;
+    TimerEvent *sp_exit_timer_ = nullptr;
 };
 
 }
diff --git a/event/engins/libev/timer_event.cpp b/event/engins/libev/timer_event.cpp
index ccad7fb460f4e73c48a277696038b5841b97fd32..c71b233297e53e41351e0365a53fc3e0aee89073 100644
--- a/event/engins/libev/timer_event.cpp
+++ b/event/engins/libev/timer_event.cpp
@@ -9,10 +9,7 @@ namespace tbox {
 namespace event {
 
 LibevTimerEvent::LibevTimerEvent(LibevLoop *wp_loop) :
-    wp_loop_(wp_loop),
-    is_inited_(false),
-    mode_(Mode::kOneshot),
-    cb_level_(0)
+    wp_loop_(wp_loop)
 {
     memset(&timer_ev_, 0, sizeof(timer_ev_));
 }
diff --git a/event/engins/libev/timer_event.h b/event/engins/libev/timer_event.h
index e4893db101e9847b6e90ebdf4425bb7047ed6a6a..4699e5f8310ee26f40015a41b2591dcc3216bd79 100644
--- a/event/engins/libev/timer_event.h
+++ b/event/engins/libev/timer_event.h
@@ -13,17 +13,17 @@ class LibevLoop;
 class LibevTimerEvent : public TimerEvent {
   public:
     explicit LibevTimerEvent(LibevLoop *wp_loop);
-    virtual ~LibevTimerEvent();
+    virtual ~LibevTimerEvent() override;
 
   public:
-    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode);
-    virtual void setCallback(const CallbackFunc &cb);
+    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode) override;
+    virtual void setCallback(const CallbackFunc &cb) override;
 
-    virtual bool isEnabled() const;
-    virtual bool enable();
-    virtual bool disable();
+    virtual bool isEnabled() const override;
+    virtual bool enable() override;
+    virtual bool disable() override;
 
-    virtual Loop* getLoop() const;
+    virtual Loop* getLoop() const override;
 
   protected:
     static void OnEventCallback(struct ev_loop*, ev_timer *p_w, int events);
@@ -32,13 +32,13 @@ class LibevTimerEvent : public TimerEvent {
   private:
     LibevLoop *wp_loop_;
     ev_timer timer_ev_;
-    bool is_inited_;
+    bool is_inited_ = false;
 
     std::chrono::milliseconds interval_;
-    Mode mode_;
+    Mode mode_ = Mode::kOneshot;
 
     CallbackFunc cb_;
-    int cb_level_;
+    int cb_level_ = 0;
 };
 
 }
diff --git a/event/engins/libevent/fd_event.cpp b/event/engins/libevent/fd_event.cpp
index db0fbc8ee09b3c886ed83356f684439428b2ddb1..77ac68c8a164d003169724b87d5a70903e795a09 100644
--- a/event/engins/libevent/fd_event.cpp
+++ b/event/engins/libevent/fd_event.cpp
@@ -10,10 +10,7 @@ namespace tbox {
 namespace event {
 
 LibeventFdEvent::LibeventFdEvent(LibeventLoop *wp_loop) :
-    wp_loop_(wp_loop),
-    is_inited_(false),
-    events_(0),
-    cb_level_(0)
+    wp_loop_(wp_loop)
 {
     event_assign(&event_, NULL, -1, 0, NULL, NULL);
 }
diff --git a/event/engins/libevent/fd_event.h b/event/engins/libevent/fd_event.h
index e2bba26b1b70db10d6ef98e835a57ea509343d06..8a9fc2a3c1bd2a06919d0369e4a5819c7c597fa6 100644
--- a/event/engins/libevent/fd_event.h
+++ b/event/engins/libevent/fd_event.h
@@ -12,17 +12,17 @@ class LibeventLoop;
 class LibeventFdEvent : public FdEvent {
   public:
     explicit LibeventFdEvent(LibeventLoop *wp_loop);
-    virtual ~LibeventFdEvent();
+    virtual ~LibeventFdEvent() override;
 
   public:
-    virtual bool initialize(int fd, short events, Mode mode);
-    virtual void setCallback(const CallbackFunc &cb);
+    virtual bool initialize(int fd, short events, Mode mode) override;
+    virtual void setCallback(const CallbackFunc &cb) override;
 
-    virtual bool isEnabled() const;
-    virtual bool enable();
-    virtual bool disable();
+    virtual bool isEnabled() const override;
+    virtual bool enable() override;
+    virtual bool disable() override;
 
-    virtual Loop* getLoop() const;
+    virtual Loop* getLoop() const override;
 
   protected:
     static void OnEventCallback(int fd, short events, void *args);
@@ -32,10 +32,10 @@ class LibeventFdEvent : public FdEvent {
     LibeventLoop *wp_loop_;
 
     struct event event_;
-    bool is_inited_;
-    short events_;
+    bool is_inited_ = false;
+    short events_ = 0;
     CallbackFunc cb_;
-    int cb_level_;
+    int cb_level_ = 0;
 };
 
 }
diff --git a/event/engins/libevent/loop.h b/event/engins/libevent/loop.h
index 58a9fe97ee818776700251ca6e0e5d6deba6816f..281bdb5f7468f91d3982dd7ab45b2d8f70461b32 100644
--- a/event/engins/libevent/loop.h
+++ b/event/engins/libevent/loop.h
@@ -11,14 +11,14 @@ namespace event {
 class LibeventLoop : public CommonLoop {
   public:
     explicit LibeventLoop();
-    virtual ~LibeventLoop();
+    virtual ~LibeventLoop() override;
 
   public:
-    virtual void runLoop(Mode mode);
-    virtual void exitLoop(const std::chrono::milliseconds &wait_time);
+    virtual void runLoop(Mode mode) override;
+    virtual void exitLoop(const std::chrono::milliseconds &wait_time) override;
 
-    virtual FdEvent* newFdEvent();
-    virtual TimerEvent* newTimerEvent();
+    virtual FdEvent* newFdEvent() override;
+    virtual TimerEvent* newTimerEvent() override;
 
   public:
     struct event_base* getEventBasePtr() const { return sp_event_base_; }
diff --git a/event/engins/libevent/timer_event.cpp b/event/engins/libevent/timer_event.cpp
index 55784dafe9b3e174e63f0aa8c85e53f4df65de87..4d0a12b3572502967a26ca4a321c2012716fc6c7 100644
--- a/event/engins/libevent/timer_event.cpp
+++ b/event/engins/libevent/timer_event.cpp
@@ -11,9 +11,7 @@ namespace tbox {
 namespace event {
 
 LibeventTimerEvent::LibeventTimerEvent(LibeventLoop *wp_loop) :
-    wp_loop_(wp_loop),
-    is_inited_(false),
-    cb_level_(0)
+    wp_loop_(wp_loop)
 {
     event_assign(&event_, NULL, -1, 0, NULL, NULL);
 }
diff --git a/event/engins/libevent/timer_event.h b/event/engins/libevent/timer_event.h
index 24edcb917e4ac25c00f12db0b0e5f08d1ff9d51a..d06ef9af6f3f614b9c90ef68de34cbf39c81e9c6 100644
--- a/event/engins/libevent/timer_event.h
+++ b/event/engins/libevent/timer_event.h
@@ -12,17 +12,17 @@ class LibeventLoop;
 class LibeventTimerEvent : public TimerEvent {
   public:
     explicit LibeventTimerEvent(LibeventLoop *wp_loop);
-    virtual ~LibeventTimerEvent();
+    virtual ~LibeventTimerEvent() override;
 
   public:
-    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode);
-    virtual void setCallback(const CallbackFunc &cb);
+    virtual bool initialize(const std::chrono::milliseconds &interval, Mode mode) override;
+    virtual void setCallback(const CallbackFunc &cb) override;
 
-    virtual bool isEnabled() const;
-    virtual bool enable();
-    virtual bool disable();
+    virtual bool isEnabled() const override;
+    virtual bool enable() override;
+    virtual bool disable() override;
 
-    virtual Loop* getLoop() const;
+    virtual Loop* getLoop() const override;
 
   protected:
     static void OnEventCallback(int, short, void *args);
@@ -31,10 +31,10 @@ class LibeventTimerEvent : public TimerEvent {
   private:
     LibeventLoop *wp_loop_;
     struct event event_;
-    bool is_inited_;
-    struct timeval interval_;
+    bool is_inited_ = false;
+    struct timeval interval_ = { 0, 0 };
     CallbackFunc cb_;
-    int cb_level_;
+    int cb_level_ = 0;
 };
 
 }
diff --git a/eventx/thread_pool.cpp b/eventx/thread_pool.cpp
index a76dd780ab733c9ba1b7a92c6070d01cf4e454f3..b3ddc30779b8d9b5f2b82416d5aa1a92fc1e6996 100644
--- a/eventx/thread_pool.cpp
+++ b/eventx/thread_pool.cpp
@@ -62,7 +62,7 @@ ThreadPool::~ThreadPool()
     delete d_;
 }
 
-bool ThreadPool::initialize(int min_thread_num, int max_thread_num)
+bool ThreadPool::initialize(size_t min_thread_num, size_t max_thread_num)
 {
     if (d_->is_ready) {
         LogWarn("it has ready, cleanup() first");
@@ -70,8 +70,8 @@ bool ThreadPool::initialize(int min_thread_num, int max_thread_num)
     }
 
     if (max_thread_num < 0 || min_thread_num < 0 ||
-        (max_thread_num != 0 && min_thread_num > max_thread_num)) {
-        LogWarn("max_thread_num or min_thread_num invalid, max:%d, min:%d", max_thread_num, min_thread_num);
+        min_thread_num > max_thread_num || max_thread_num == 0) {
+        LogWarn("min_thread_num or max_thread_num invalid, min:%d, max:%d", min_thread_num, max_thread_num);
         return false;
     }
 
@@ -80,7 +80,7 @@ bool ThreadPool::initialize(int min_thread_num, int max_thread_num)
         d_->min_thread_num = min_thread_num;
         d_->max_thread_num = max_thread_num;
 
-        for (int i = 0; i < min_thread_num; ++i)
+        for (size_t i = 0; i < min_thread_num; ++i)
             if (!createWorker())
                 return false;
     }
@@ -124,8 +124,7 @@ ThreadPool::TaskToken ThreadPool::execute(const NonReturnFunc &backend_task, con
 
         d_->undo_tasks_token.at(level).push_back(token);
         //! 如果空间线程不够，且还可以再创建新的线程
-        if (d_->idle_thread_num == 0 &&
-            (d_->max_thread_num == 0 || d_->threads_cabinet.size() < d_->max_thread_num))
+        if (d_->idle_thread_num == 0 && d_->threads_cabinet.size() < d_->max_thread_num)
             createWorker();
     }
 
@@ -135,6 +134,19 @@ ThreadPool::TaskToken ThreadPool::execute(const NonReturnFunc &backend_task, con
     return token;
 }
 
+ThreadPool::TaskStatus ThreadPool::getTaskStatus(TaskToken task_token) const
+{
+    std::lock_guard<std::mutex> lg(d_->lock);
+
+    if (d_->undo_tasks_cabinet.at(task_token) != nullptr)
+        return TaskStatus::kWaiting;
+
+    if (d_->doing_tasks_token.find(task_token) != d_->doing_tasks_token.end())
+        return TaskStatus::kExecuting;
+
+    return TaskStatus::kNotFound;
+}
+
 /**
  * 返回值如下：
  * 0: 取消成功
@@ -208,8 +220,8 @@ void ThreadPool::threadProc(ThreadToken thread_token)
 
             /**
              * 为防止反复创建线程，此处做优化：
-             * 如果当前已有空闲的线程在等待，且当前的线程个数已超过长驻线程数，说明线程数据已满足现有要求
-             * 则退出当前线程
+             * 如果当前已有空闲的线程在等待，且当前的线程个数已超过长驻线程数，说明线程数据已满足现有要求则退出当前线程
+             * 但这也会引起另一个小问题：如果 min_thread_num = 0，那么一旦执行过一次，线程池中至少会保留一个工作线程
              */
             if (d_->idle_thread_num > 0 && d_->threads_cabinet.size() > d_->min_thread_num) {
                 LogDbg("thread %u will exit, no more work.", thread_token.id());
diff --git a/eventx/thread_pool.h b/eventx/thread_pool.h
index 6d2de094348c1c8338b133da105d4403c52fd743..b8dedd48411c17828704e3cb8e25b7ca8bab79c0 100644
--- a/eventx/thread_pool.h
+++ b/eventx/thread_pool.h
@@ -1,6 +1,7 @@
 #ifndef TBOX_THREAD_POOL_H
 #define TBOX_THREAD_POOL_H
 
+#include <limits>
 #include <functional>
 #include <tbox/event/forward.h>
 #include <tbox/base/cabinet_token.h>
@@ -27,11 +28,11 @@ class ThreadPool {
      * 初始化线程池，指定常驻线程数与最大线程数
      *
      * \param min_thread_num    常驻线程数，必须 >=0
-     * \param max_thread_num    最大线程数，必须 >=0，=0表示不限定最大线程数量
+     * \param max_thread_num    最大线程数，必须 >= min_thread_num 且 > 0
      *
      * \return bool     是否成功
      */
-    bool initialize(int min_thread_num = 0, int max_thread_num = 0);
+    bool initialize(size_t min_thread_num = 0, size_t max_thread_num = std::numeric_limits<size_t>::max());
 
     using NonReturnFunc = std::function<void ()>;
 
@@ -56,6 +57,15 @@ class ThreadPool {
      */
     TaskToken execute(const NonReturnFunc &backend_task, const NonReturnFunc &main_cb, int prio = 0);
 
+    enum class TaskStatus {
+        kWaiting,   //! 等待中
+        kExecuting, //! 执行中
+        kNotFound   //! 未找到（可能已完成）
+    };
+
+    //! 获取任务的状态
+    TaskStatus getTaskStatus(TaskToken task_token) const;
+
     /**
      * 取消任务
      *
diff --git a/eventx/thread_pool_test.cpp b/eventx/thread_pool_test.cpp
index c4c163a820a0721ec031958f5006385ac166976a..ea328a669d7ea356bec3b619179fc5aad5504dbe 100644
--- a/eventx/thread_pool_test.cpp
+++ b/eventx/thread_pool_test.cpp
@@ -3,6 +3,7 @@
 
 #include <tbox/base/log.h>
 #include <tbox/event/loop.h>
+#include <tbox/event/timer_event.h>
 
 #include "thread_pool.h"
 
@@ -168,4 +169,60 @@ TEST(ThreadPool, prio) {
     delete loop;
 }
 
+/**
+ * 优先级
+ *
+ * 期望优先级最高的先被执行
+ */
+TEST(ThreadPool, getStatus) {
+    Loop *loop = Loop::New();
+
+    ThreadPool *tp = new ThreadPool(loop);
+    ASSERT_TRUE(tp->initialize(1,1));
+
+    auto task1 = tp->execute([] { std::this_thread::sleep_for(std::chrono::milliseconds(100)); });
+    auto task2 = tp->execute([] { std::this_thread::sleep_for(std::chrono::milliseconds(100)); });
+
+    auto t1 = loop->newTimerEvent();
+    t1->initialize(chrono::milliseconds(50), Event::Mode::kOneshot);
+    t1->enable();
+    t1->setCallback(
+        [&] {
+            EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kExecuting);
+            EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kWaiting);
+        }
+    );
+
+    auto t2 = loop->newTimerEvent();
+    t2->initialize(chrono::milliseconds(150), Event::Mode::kOneshot);
+    t2->enable();
+    t2->setCallback(
+        [&] {
+            EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kNotFound);
+            EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kExecuting);
+        }
+    );
+
+    auto t3 = loop->newTimerEvent();
+    t3->initialize(chrono::milliseconds(250), Event::Mode::kOneshot);
+    t3->enable();
+    t3->setCallback(
+        [&] {
+            EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kNotFound);
+            EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kNotFound);
+        }
+    );
+
+    loop->exitLoop(std::chrono::milliseconds(300));
+    loop->runLoop();
+
+    tp->cleanup();
+
+    delete t3;
+    delete t2;
+    delete t1;
+    delete tp;
+    delete loop;
+}
+
 }
diff --git a/main/context_imp.cpp b/main/context_imp.cpp
index a7ecc621e769bc5ff5d6140401a974f7a6cb5966..6ce12559650ce75f6d0aacc8c706d71b945b7297 100644
--- a/main/context_imp.cpp
+++ b/main/context_imp.cpp
@@ -39,7 +39,7 @@ ContextImp::~ContextImp()
 
 void ContextImp::fillDefaultConfig(Json &cfg) const
 {
-    cfg["thread_pool"] = R"({"min":1, "max":0})"_json;
+    cfg["thread_pool"] = R"({"min":1, "max":5})"_json;
 }
 
 bool ContextImp::initialize(const Json &cfg)
@@ -116,7 +116,7 @@ void ContextImp::buildTerminalNodes()
     TerminalNodes *wp_nodes = sp_terminal_;
 
     auto ctx_node = wp_nodes->createDirNode("This is Context directory");
-    wp_nodes->mountNode(wp_nodes->rootNode(), ctx_node, "context");
+    wp_nodes->mountNode(wp_nodes->rootNode(), ctx_node, "ctx");
 
     auto loop_node = wp_nodes->createDirNode("This is Loop directory");
     wp_nodes->mountNode(ctx_node, loop_node, "loop");
diff --git a/terminal/impl/func_node.cpp b/terminal/impl/func_node.cpp
index 15b767bbaa56a924a37fd7b43f584f27a3a7fa5d..0a9ada2e4f596f4cc5a79f99fbcbf27be3484bee 100644
--- a/terminal/impl/func_node.cpp
+++ b/terminal/impl/func_node.cpp
@@ -2,7 +2,7 @@
 
 namespace tbox::terminal {
 FuncNode::FuncNode(const Func &func, const std::string &help) :
-    Node(help), func_(func), help_(help)
+    Node(help), func_(func)
 { }
 
 void FuncNode::execute(const Session &s, const Args &a) const
diff --git a/terminal/impl/func_node.h b/terminal/impl/func_node.h
index a9857249625b7fda9452eabc5ddb62bc26c5208e..bf6d017407650b9f30baefe7c1af6e47c29eac2e 100644
--- a/terminal/impl/func_node.h
+++ b/terminal/impl/func_node.h
@@ -15,7 +15,6 @@ class FuncNode : public Node {
 
   private:
     Func func_;
-    std::string help_;
 };
 
 }