apro：尝试使用shared_mutex提升效率。

client/client.cpp

@@ -17,7 +17,7 @@ CClient::CClient(const std::shared_ptr<spdlog::logger>& logger) : logger_(logger
 {
     client_ = std::make_shared<CTcpClient>(io_context_, logger_);
     supported_.push_back("Get");
-    sleep_.set_timeout(2000);
+    sleep_.set_timeout(5000);
 }
 
 CClient::~CClient()

server/server.cpp

@@ -4,8 +4,8 @@
 
 using namespace ofen;
 constexpr int g_MaxCacheLen = 1024 * 1024 * 50;
-constexpr int check_idle_percycle = 1000 * 60;   // 毫秒
+constexpr int check_idle_percycle = 1000 * 30;   // 毫秒
-constexpr int remove_after_time = 60 * 10;       // 秒
+constexpr int remove_after_time = 60;            // 秒
 CTcpServer::CTcpServer(asio::io_context& io_context, const std::shared_ptr<spdlog::logger>& logger)
     : io_context_(io_context), acceptor_(io_context), logger_(logger)
 {
@@ -60,7 +60,7 @@ bool CTcpServer::start(unsigned short port)
 void CTcpServer::stop()
 {
     acceptor_.close();
-    std::lock_guard<std::mutex> lock(cli_mut_);
+    std::unique_lock<std::shared_mutex> lock(cli_mut_);
     for (auto& [key, thread] : client_threads_) {
         if (thread.joinable()) {
             thread.join();
@@ -72,7 +72,7 @@ void CTcpServer::stop()
 std::vector<TaskList> CTcpServer::get_clients()
 {
     std::vector<TaskList> result;
-    std::lock_guard<std::mutex> lock(cli_mut_);
+    std::shared_lock<std::shared_mutex> lock(cli_mut_);
     for (const auto& item : client_map_) {
         TaskList t;
         t.id_ = item.first;
@@ -110,7 +110,7 @@ void CTcpServer::trans_data(CFrameBuffer* buf)
     std::shared_ptr<ClientCache> tcli = nullptr;
 
     {
-        std::lock_guard<std::mutex> lock(cli_mut_);
+        std::shared_lock<std::shared_mutex> lock(cli_mut_);
         if (client_map_.count(buf->fid_)) {
             fcli = client_map_[buf->fid_];
         }
@@ -178,7 +178,7 @@ void CTcpServer::trans_data(CFrameBuffer* buf)
 bool CTcpServer::check_double(CFrameBuffer* buf, std::shared_ptr<ClientCache>& fcli,
                               std::shared_ptr<ClientCache>& tcli)
 {
-    std::lock_guard<std::mutex> lock(cli_mut_);
+    std::shared_lock<std::shared_mutex> lock(cli_mut_);
     if (client_map_.count(buf->fid_)) {
         fcli = client_map_[buf->fid_];
     }
@@ -215,7 +215,7 @@ void CTcpServer::accept_client()
 
             bool can = false;
             {
-                std::lock_guard<std::mutex> lock(cli_mut_);
+                std::unique_lock<std::shared_mutex> lock(cli_mut_);
                 if (client_map_.size() >= 100) {
                     logger_->info("Max client connections reached. Closing connection from {}", client_key);
                     socket->close();
@@ -242,7 +242,7 @@ void CTcpServer::accept_client()
 void CTcpServer::th_client(std::shared_ptr<asio::ip::tcp::socket> socket, const std::string& client_key)
 {
     std::shared_ptr<int> deleter(new int(0), [&](int* p) {
-        std::lock_guard<std::mutex> lock(cli_mut_);
+        std::unique_lock<std::shared_mutex> lock(cli_mut_);
         delete p;
         client_map_.erase(client_key);
         if (client_threads_.find(client_key) != client_threads_.end()) {
@@ -256,7 +256,7 @@ void CTcpServer::th_client(std::shared_ptr<asio::ip::tcp::socket> socket, const
         std::shared_ptr<ClientCache> cache = nullptr;
 
         {
-            std::lock_guard<std::mutex> lock(cli_mut_);
+            std::shared_lock<std::shared_mutex> lock(cli_mut_);
             if (!client_map_.count(client_key)) {
                 logger_->error("Not Find Client{} in cache.", client_key);
                 return;
@@ -278,7 +278,7 @@ void CTcpServer::th_client(std::shared_ptr<asio::ip::tcp::socket> socket, const
                 auto* frame = CTransProtocal::parse(cache->buffer_);
                 if (frame) {
                     if (frame->type_ == TYPE_HEARTS) {
-                        std::lock_guard<std::mutex> lock(cli_mut_);
+                        std::unique_lock<std::shared_mutex> lock(cli_mut_);
                         if (client_map_.count(client_key)) {
                             auto& cli = client_map_[client_key];
                             cli->last_active_time_ = std::chrono::high_resolution_clock::now();
@@ -336,7 +336,7 @@ void CTcpServer::monitor_idle()
             break;
         }
         std::vector<std::string> remove_vec;
-        std::lock_guard<std::mutex> lock(cli_mut_);
+        std::unique_lock<std::shared_mutex> lock(cli_mut_);
         for (auto& item : client_map_) {
             auto now = std::chrono::high_resolution_clock::now();
             auto duration =

server/server.h

@@ -1,11 +1,12 @@
 #pragma once
+#include <chrono>
 #include <list>
 #include <net_base.h>
 #include <of_util.h>
+#include <shared_mutex>
 #include <string>
 #include <util.h>
 #include <vector>
-#include <chrono>
 
 using namespace ofen;
 using high_c = std::chrono::time_point<std::chrono::high_resolution_clock>;
@@ -58,8 +59,7 @@ private:
     std::shared_ptr<spdlog::logger> logger_;
     std::map<std::string, std::shared_ptr<ClientCache>> client_map_;
     std::map<std::string, std::thread> client_threads_;
-    std::mutex cli_mut_;
+    std::shared_mutex cli_mut_;
-    std::mutex buf_mut_;
     std::thread th_monitor_idle_;
     std::string server_ip_;
     CThreadSleep sleep_;