Optimize the thread initialization and cleanup logic code.

Author: matyhtf

core-tests/src/network/stream.cpp

@@ -83,6 +83,8 @@ TEST(stream, send) {
         swoole_event_wait();
 
         kill(getpid(), SIGTERM);
+
+        swoole_signal_unblock_all();
     });
 
     serv.onWorkerStart = [&lock](Server *serv, Worker *worker) { lock.unlock(); };

core-tests/src/os/process_pool.cpp

@@ -277,6 +277,7 @@ TEST(process_pool, listen) {
         c.close();
 
         kill(getpid(), SIGTERM);
+        swoole_signal_unblock_all();
     });
 
     ASSERT_EQ(pool.wait(), SW_OK);

ext-src/swoole_thread.cc

@@ -428,7 +428,7 @@ void php_swoole_thread_start(std::shared_ptr<Thread> thread, zend_string *file,
     PG(enable_dl) = 0;
 #endif
 
-    swoole_thread_init();
+    swoole_thread_init(false);
 
     if (php_request_startup() != SUCCESS) {
         EG(exit_status) = 1;
@@ -471,7 +471,7 @@ void php_swoole_thread_start(std::shared_ptr<Thread> thread, zend_string *file,
     zend_string_release(file);
     thread->exit(EG(exit_status));
     ts_free_thread();
-    swoole_thread_clean();
+    swoole_thread_clean(false);
     thread_num.fetch_sub(1);
 }
 

include/swoole.h

@@ -581,8 +581,8 @@ void swoole_exit(int __status);
 pid_t swoole_fork(int flags);
 pid_t swoole_fork_exec(const std::function<void(void)> &child_fn);
 pid_t swoole_waitpid(pid_t __pid, int *__stat_loc, int __options);
-void swoole_thread_init(void);
-void swoole_thread_clean(void);
+void swoole_thread_init(bool main_thread);
+void swoole_thread_clean(bool main_thread);
 void swoole_redirect_stdout(int new_fd);
 void swoole_redirect_stdout(const char *file);
 int swoole_shell_exec(const char *command, pid_t *pid, bool get_error_stream);
@@ -696,6 +696,7 @@ struct ThreadGlobal {
 #endif
     String *buffer_stack;
     Reactor *reactor;
+    Logger *logger;
     Timer *timer;
     TimerScheduler timer_scheduler;
     MessageBus *message_bus;

include/swoole_signal.h

@@ -53,6 +53,7 @@ SW_API swSignalHandler swoole_signal_get_handler(int signo);
 
 SW_API void swoole_signal_clear(void);
 SW_API void swoole_signal_block_all(void);
+SW_API void swoole_signal_unblock_all(void);
 SW_API char *swoole_signal_to_str(int sig);
 SW_API void swoole_signal_callback(int signo);
 /**

src/core/base.cc

@@ -54,6 +54,7 @@
 #endif
 #endif
 
+using swoole::Logger;
 using swoole::NameResolver;
 using swoole::String;
 using swoole::coroutine::System;
@@ -101,12 +102,10 @@ thread_local swoole::ThreadGlobal SwooleTG = {};
 thread_local char sw_error[SW_ERROR_MSG_SIZE];
 std::mutex sw_thread_lock;
 
-static swoole::Logger *g_logger_instance = nullptr;
-
 static void swoole_fatal_error_impl(int code, const char *format, ...);
 
 swoole::Logger *sw_logger() {
-    return g_logger_instance;
+    return SwooleTG.logger;
 }
 
 void *sw_malloc(size_t size) {
@@ -170,7 +169,7 @@ void swoole_init(void) {
 
     SwooleG.pid = getpid();
 
-    g_logger_instance = new swoole::Logger;
+    swoole_thread_init(true);
 
 #ifdef SW_DEBUG
     sw_logger()->set_level(0);
@@ -190,8 +189,6 @@ void swoole_init(void) {
         SwooleG.max_sockets = SW_MIN((uint32_t) rlmt.rlim_cur, SW_SESSION_LIST_SIZE);
     }
 
-    SwooleTG.buffer_stack = new swoole::String(SW_STACK_BUFFER_SIZE);
-
     if (!swoole_set_task_tmpdir(SW_TASK_TMP_DIR)) {
         exit(4);
     }
@@ -238,23 +235,10 @@ SW_API int swoole_api_version_id(void) {
 SW_EXTERN_C_END
 
 void swoole_clean(void) {
-    if (SwooleTG.timer) {
-        swoole_timer_free();
-    }
-    if (SwooleTG.reactor) {
-        swoole_event_free();
-    }
+    swoole_thread_clean(true);
     if (SwooleG.memory_pool != nullptr) {
         delete SwooleG.memory_pool;
     }
-    if (g_logger_instance) {
-        delete g_logger_instance;
-        g_logger_instance = nullptr;
-    }
-    if (SwooleTG.buffer_stack) {
-        delete SwooleTG.buffer_stack;
-        SwooleTG.buffer_stack = nullptr;
-    }
     SW_LOOP_N(SW_MAX_HOOK_TYPE) {
         if (SwooleG.hooks[i]) {
             auto hooks = static_cast<std::list<swoole::Callback> *>(SwooleG.hooks[i]);
@@ -398,14 +382,9 @@ pid_t swoole_fork(int flags) {
                 swoole_trace_log(SW_TRACE_REACTOR, "reactor has been destroyed");
             }
         } else {
-            /**
-             * close log fd
-             */
             sw_logger()->close();
         }
-        /**
-         * reset signal handler
-         */
+        // reset signal handler
         swoole_signal_clear();
 
         if (swoole_isset_hook(SW_GLOBAL_HOOK_AFTER_FORK)) {
@@ -416,18 +395,34 @@ pid_t swoole_fork(int flags) {
     return pid;
 }
 
-void swoole_thread_init(void) {
+void swoole_thread_init(bool main_thread) {
     if (!SwooleTG.buffer_stack) {
         SwooleTG.buffer_stack = new String(SW_STACK_BUFFER_SIZE);
     }
-    swoole_signal_block_all();
+    if (!SwooleTG.logger) {
+        SwooleTG.logger = new Logger();
+    }
+    if (!main_thread) {
+        swoole_signal_block_all();
+    }
 }
 
-void swoole_thread_clean(void) {
+void swoole_thread_clean(bool main_thread) {
+    if (SwooleTG.timer) {
+        swoole_timer_free();
+    }
+    if (SwooleTG.reactor) {
+        swoole_event_free();
+    }
     if (SwooleTG.buffer_stack) {
         delete SwooleTG.buffer_stack;
         SwooleTG.buffer_stack = nullptr;
     }
+    if (SwooleTG.logger) {
+        SwooleTG.logger->close();
+        delete SwooleTG.logger;
+        SwooleTG.logger = nullptr;
+    }
 }
 
 void swoole_dump_ascii(const char *data, size_t size) {

src/os/async_thread.cc

@@ -228,7 +228,7 @@ class ThreadPool {
 
 void ThreadPool::main_func(bool is_core_worker) {
     bool exit_flag = false;
-    swoole_thread_init();
+    swoole_thread_init(false);
 
     while (running) {
         event_mutex.lock();
@@ -313,7 +313,7 @@ void ThreadPool::main_func(bool is_core_worker) {
             --n_waiting;
         }
     }
-    swoole_thread_clean();
+    swoole_thread_clean(false);
 }
 
 void ThreadPool::create_thread(const bool is_core_worker) {

src/os/signal.cc

@@ -78,15 +78,21 @@ char *swoole_signal_to_str(int sig) {
     return buf;
 }
 
-/**
- * block all singal
- */
 void swoole_signal_block_all(void) {
     sigset_t mask;
     sigfillset(&mask);
     int ret = pthread_sigmask(SIG_BLOCK, &mask, nullptr);
     if (ret < 0) {
-        swoole_sys_warning("pthread_sigmask() failed");
+        swoole_sys_warning("pthread_sigmask(SIG_BLOCK) failed");
+    }
+}
+
+void swoole_signal_unblock_all(void) {
+    sigset_t mask;
+    sigfillset(&mask);
+    int ret = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
+    if (ret < 0) {
+        swoole_sys_warning("pthread_sigmask(SIG_UNBLOCK) failed");
     }
 }
 

src/server/reactor_thread.cc

@@ -720,9 +720,9 @@ int Server::start_reactor_threads() {
 
     SW_LOOP_N(reactor_num) {
         get_thread(i)->thread = std::thread([=]() {
-            swoole_thread_init();
+            swoole_thread_init(false);
             reactor_thread_main_loop(this, i);
-            swoole_thread_clean();
+            swoole_thread_clean(false);
         });
     }