update

Author: xiehuc

ext/src/http/client/curl/http_client_curl.cc

@@ -352,29 +352,20 @@ void HttpClient::MaybeSpawnBackgroundThread()
         int still_running = 1;
         std::chrono::system_clock::time_point last_free_job_timepoint =
             std::chrono::system_clock::now();
+        bool need_wait_more = false;
         while (true)
         {
           CURLMsg *msg;
           int queued;
           CURLMcode mc = curl_multi_perform(self->multi_handle_, &still_running);
 
-          std::chrono::milliseconds wait_for;
-#if LIBCURL_VERSION_NUM >= 0x074200
-          // only avaliable with curl_multi_poll
-          wait_for = self->background_thread_wait_for_;
-#endif
-          if (self->is_shutdown.load(std::memory_order_acquire))
-          {
-            wait_for = std::chrono::milliseconds{0};
-          }
-
           // According to https://curl.se/libcurl/c/curl_multi_perform.html, when mc is not OK, we
           // can not curl_multi_perform it again
           if (mc != CURLM_OK)
           {
             self->resetMultiHandle();
           }
-          else if (still_running || now - last_free_job_timepoint < wait_for)
+          else if (still_running || need_wait_more)
           {
         // curl_multi_poll is added from libcurl 7.66.0, before 7.68.0, we can only wait util
         // timeout to do the rest jobs
@@ -433,13 +424,31 @@ void HttpClient::MaybeSpawnBackgroundThread()
             still_running = 1;
           }
 
+          std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
           if (still_running > 0)
           {
             last_free_job_timepoint = now;
+            need_wait_more          = false;
+            continue;
+          }
+
+          std::chrono::milliseconds wait_for;
+#if LIBCURL_VERSION_NUM >= 0x074200
+          // only avaliable with curl_multi_poll
+          wait_for = self->background_thread_wait_for_;
+#endif
+          if (self->is_shutdown.load(std::memory_order_acquire))
+          {
+            wait_for = std::chrono::milliseconds{0};
+          }
+
+          if (now - last_free_job_timepoint < wait_for)
+          {
+            need_wait_more = true;
             continue;
           }
 
-          if (still_running == 0 && now - last_free_job_timepoint > wait_for)
+          if (still_running == 0)
           {
             std::lock_guard<std::mutex> lock_guard{self->background_thread_m_};
             // Double check, make sure no more pending sessions after locking background thread

ext/test/http/curl_http_test.cc

@@ -526,3 +526,21 @@ TEST_F(BasicCurlHttpTests, FinishInAsyncCallback)
     }
   }
 }
+
+TEST_F(BasicCurlHttpTests, ElegantQuitQuick)
+{
+  auto http_client = http_client::HttpClientFactory::Create();
+  std::dynamic_pointer_cast<curl::HttpClient>(http_client)->MaybeSpawnBackgroundThread();
+  auto beg     = std::chrono::system_clock::now();
+  auto session = http_client->CreateSession("http://127.0.0.1:19000/get/");
+  auto request = session->CreateRequest();
+  request->SetUri("get/");
+  auto handler = std::make_shared<GetEventHandler>();
+  session->SendRequest(handler);
+  http_client->FinishAllSessions();
+  http_client.reset();
+  // when use background_thread_wait_for_ should have no side effort on elegant quit
+  ASSERT_TRUE(std::chrono::system_clock::now() - beg < std::chrono::milliseconds{5});
+  ASSERT_TRUE(handler->is_called_);
+  ASSERT_TRUE(handler->got_response_);
+}