grpc 1.64.0 → 1.68.1

data/src/core/lib/event_engine/resolved_address.cc

@@ -14,14 +14,11 @@
 
 #include "src/core/lib/iomgr/resolved_address.h"
 
-#include <string.h>
-
-#include "absl/log/check.h"
-
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
+#include <string.h>
 
+#include "absl/log/check.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
 
 // IWYU pragma: no_include <sys/socket.h>
@@ -51,6 +48,9 @@ EventEngine::ResolvedAddress CreateResolvedAddress(
 
 grpc_resolved_address CreateGRPCResolvedAddress(
     const EventEngine::ResolvedAddress& ra) {
+  static_assert(
+      GRPC_MAX_SOCKADDR_SIZE == EventEngine::ResolvedAddress::MAX_SIZE_BYTES,
+      "size should match");
   grpc_resolved_address grpc_addr;
   memset(&grpc_addr, 0, sizeof(grpc_resolved_address));
   memcpy(grpc_addr.addr, ra.address(), ra.size());

data/src/core/lib/event_engine/shim.cc

@@ -30,7 +30,7 @@ bool UseEventEngineClient() {
   return grpc_core::IsEventEngineClientEnabled();
 #elif defined(GPR_WINDOWS) && !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
   return grpc_core::IsEventEngineClientEnabled();
-#elif defined(GRPC_IOS_EVENT_ENGINE_CLIENT)
+#elif GRPC_IOS_EVENT_ENGINE_CLIENT
   return true;
 #else
   return false;

data/src/core/lib/event_engine/slice.cc

@@ -14,18 +14,15 @@
 
 #include "src/core/lib/slice/slice.h"
 
+#include <grpc/event_engine/slice.h>
+#include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
 #include "absl/log/check.h"
-
-#include <grpc/event_engine/slice.h>
-#include <grpc/slice.h>
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
 

data/src/core/lib/event_engine/slice_buffer.cc

@@ -12,12 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <stddef.h>
-
 #include <grpc/event_engine/slice.h>
 #include <grpc/event_engine/slice_buffer.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/port_platform.h>
+#include <stddef.h>
 
 #include "src/core/lib/slice/slice.h"
 

data/src/core/lib/event_engine/tcp_socket_utils.cc

@@ -54,16 +54,14 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-
-#include <grpc/support/log.h>
-
-#include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/host_port.h"
+#include "src/core/util/status_helper.h"
+#include "src/core/util/uri.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -286,8 +284,8 @@ int ResolvedAddressGetPort(const EventEngine::ResolvedAddress& resolved_addr) {
       return 1;
 #endif
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in ResolvedAddressGetPort",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in ResolvedAddressGetPort";
       abort();
   }
 }
@@ -309,8 +307,8 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
           htons(static_cast<uint16_t>(port));
       return;
     default:
-      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
-              addr->sa_family);
+      LOG(ERROR) << "Unknown socket family " << addr->sa_family
+                 << " in grpc_sockaddr_set_port";
       abort();
   }
 }
@@ -446,8 +444,7 @@ absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
   grpc_resolved_address addr;
   absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Parse(address_str);
   if (!uri.ok()) {
-    gpr_log(GPR_ERROR, "Failed to parse URI. Error: %s",
-            uri.status().ToString().c_str());
+    LOG(ERROR) << "Failed to parse URI. Error: " << uri.status();
   }
   GRPC_RETURN_IF_ERROR(uri.status());
   CHECK(grpc_parse_uri(*uri, &addr));

data/src/core/lib/event_engine/tcp_socket_utils.h

@@ -14,14 +14,14 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_TCP_SOCKET_UTILS_H
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/port_platform.h>
-
 namespace grpc_event_engine {
 namespace experimental {
 

data/src/core/lib/event_engine/thread_local.h

@@ -29,4 +29,4 @@ class ThreadLocal {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_LOCAL_H

data/src/core/lib/event_engine/thread_pool/thread_count.cc

@@ -13,19 +13,17 @@
 // limitations under the License.
 #include "src/core/lib/event_engine/thread_pool/thread_count.h"
 
+#include <grpc/support/port_platform.h>
 #include <inttypes.h>
 
 #include <cstddef>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/util/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -52,8 +50,8 @@ absl::Status LivingThreadCount::BlockUntilThreadCount(
       prev_thread_count = curr_threads;
       timeout_baseline = grpc_core::Timestamp::Now();
     }
-    GRPC_LOG_EVERY_N_SEC_DELAYED(
-        log_rate.seconds(), GPR_DEBUG,
+    GRPC_LOG_EVERY_N_SEC_DELAYED_DEBUG(
+        log_rate.seconds(),
         "Waiting for thread pool to idle before %s. (%" PRIdPTR " to %" PRIdPTR
         "). Timing out in %0.f seconds.",
         why, curr_threads, desired_threads,

data/src/core/lib/event_engine/thread_pool/thread_count.h

@@ -14,6 +14,9 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_COUNT_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_COUNT_H
 
+#include <grpc/support/cpu.h>
+#include <grpc/support/port_platform.h>
+
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
@@ -22,13 +25,9 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-
-#include <grpc/support/cpu.h>
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
+#include "src/core/util/useful.h"
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/thread_pool/thread_pool.h

@@ -13,15 +13,13 @@
 // limitations under the License.
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_POOL_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_THREAD_POOL_H
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 #include <stddef.h>
 
 #include <memory>
 
 #include "absl/functional/any_invocable.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/forkable.h"
 
 namespace grpc_event_engine {

data/src/core/lib/event_engine/thread_pool/thread_pool_factory.cc

@@ -11,16 +11,15 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#include <grpc/support/port_platform.h>
 #include <stddef.h>
 
 #include <memory>
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
-#include "src/core/lib/gprpp/no_destruct.h"
+#include "src/core/util/no_destruct.h"
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -17,6 +17,8 @@
 //
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
 
+#include <grpc/support/port_platform.h>
+#include <grpc/support/thd_id.h>
 #include <inttypes.h>
 
 #include <atomic>
@@ -27,25 +29,21 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 #include "absl/types/optional.h"
-
-#include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/thd_id.h>
-
-#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/thread_local.h"
-#include "src/core/lib/event_engine/trace.h"
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/env.h"
-#include "src/core/lib/gprpp/examine_stack.h"
-#include "src/core/lib/gprpp/thd.h"
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/util/backoff.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/env.h"
+#include "src/core/util/examine_stack.h"
+#include "src/core/util/thd.h"
+#include "src/core/util/time.h"
 
 #ifdef GPR_POSIX_SYNC
 #include <csignal>
@@ -156,11 +154,10 @@ std::atomic<size_t> g_reported_dump_count{0};
 void DumpSignalHandler(int /* sig */) {
   const auto trace = grpc_core::GetCurrentStackTrace();
   if (!trace.has_value()) {
-    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": Stack trace not available",
-            gpr_thd_currentid());
+    LOG(ERROR) << "DumpStack::" << gpr_thd_currentid()
+               << ": Stack trace not available";
   } else {
-    gpr_log(GPR_ERROR, "DumpStack::%" PRIdPTR ": %s", gpr_thd_currentid(),
-            trace->c_str());
+    LOG(ERROR) << "DumpStack::" << gpr_thd_currentid() << ": " << trace.value();
   }
   g_reported_dump_count.fetch_add(1);
   grpc_core::Thread::Kill(gpr_thd_currentid());
@@ -175,8 +172,8 @@ thread_local WorkQueue* g_local_queue = nullptr;
 WorkStealingThreadPool::WorkStealingThreadPool(size_t reserve_threads)
     : pool_{std::make_shared<WorkStealingThreadPoolImpl>(reserve_threads)} {
   if (g_log_verbose_failures) {
-    GRPC_EVENT_ENGINE_TRACE(
-        "%s", "WorkStealingThreadPool verbose failures are enabled");
+    GRPC_TRACE_LOG(event_engine, INFO)
+        << "WorkStealingThreadPool verbose failures are enabled";
   }
   pool_->Start();
 }
@@ -227,18 +224,19 @@ void WorkStealingThreadPool::PostforkChild() { pool_->Postfork(); }
 
 WorkStealingThreadPool::WorkStealingThreadPoolImpl::WorkStealingThreadPoolImpl(
     size_t reserve_threads)
-    : reserve_threads_(reserve_threads), queue_(this), lifeguard_(this) {}
+    : reserve_threads_(reserve_threads), queue_(this) {}
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Start() {
   for (size_t i = 0; i < reserve_threads_; i++) {
     StartThread();
   }
-  lifeguard_.Start();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_ = std::make_unique<Lifeguard>(this);
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Run(
     EventEngine::Closure* closure) {
-  DCHECK(quiesced_.load(std::memory_order_relaxed) == false);
+  CHECK(!IsQuiesced());
   if (g_local_queue != nullptr && g_local_queue->owner() == this) {
     g_local_queue->Add(closure);
   } else {
@@ -266,7 +264,6 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::StartThread() {
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
-  gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::Quiesce");
   SetShutdown(true);
   // Wait until all threads have exited.
   // Note that if this is a threadpool thread then we won't exit this thread
@@ -283,7 +280,8 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   }
   CHECK(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
-  lifeguard_.BlockUntilShutdownAndReset();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_.reset();
 }
 
 bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetThrottled(
@@ -317,7 +315,8 @@ bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::IsQuiesced() {
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
-  gpr_log(GPR_INFO, "WorkStealingThreadPoolImpl::PrepareFork");
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "WorkStealingThreadPoolImpl::PrepareFork";
   SetForking(true);
   work_signal_.SignalAll();
   auto threads_were_shut_down = living_thread_count_.BlockUntilThreadCount(
@@ -325,7 +324,8 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::PrepareFork() {
   if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
     DumpStacksAndCrash();
   }
-  lifeguard_.BlockUntilShutdownAndReset();
+  grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
+  lifeguard_.reset();
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Postfork() {
@@ -347,10 +347,9 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::UntrackThread(
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::DumpStacksAndCrash() {
   grpc_core::MutexLock lock(&thd_set_mu_);
-  gpr_log(GPR_ERROR,
-          "Pool did not quiesce in time, gRPC will not shut down cleanly. "
-          "Dumping all %zu thread stacks.",
-          thds_.size());
+  LOG(ERROR) << "Pool did not quiesce in time, gRPC will not shut down "
+                "cleanly. Dumping all "
+             << thds_.size() << " thread stacks.";
   for (const auto tid : thds_) {
     grpc_core::Thread::Signal(tid, kDumpStackSignal);
   }
@@ -374,9 +373,7 @@ WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Lifeguard(
                    .set_max_backoff(kLifeguardMaxSleepBetweenChecks)
                    .set_multiplier(1.3)),
       lifeguard_should_shut_down_(std::make_unique<grpc_core::Notification>()),
-      lifeguard_is_shut_down_(std::make_unique<grpc_core::Notification>()) {}
-
-void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::Start() {
+      lifeguard_is_shut_down_(std::make_unique<grpc_core::Notification>()) {
   // lifeguard_running_ is set early to avoid a quiesce race while the
   // lifeguard is still starting up.
   lifeguard_running_.store(true);
@@ -401,9 +398,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
       if (pool_->IsQuiesced()) break;
     } else {
       lifeguard_should_shut_down_->WaitForNotificationWithTimeout(
-          absl::Milliseconds(
-              (backoff_.NextAttemptTime() - grpc_core::Timestamp::Now())
-                  .millis()));
+          absl::Milliseconds(backoff_.NextAttemptDelay().millis()));
     }
     MaybeStartNewThread();
   }
@@ -411,13 +406,12 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
   lifeguard_is_shut_down_->Notify();
 }
 
-void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
-    BlockUntilShutdownAndReset() {
+WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::~Lifeguard() {
   lifeguard_should_shut_down_->Notify();
   while (lifeguard_running_.load(std::memory_order_relaxed)) {
-    GRPC_LOG_EVERY_N_SEC_DELAYED(kBlockingQuiesceLogRateSeconds, GPR_DEBUG,
-                                 "%s",
-                                 "Waiting for lifeguard thread to shut down");
+    GRPC_LOG_EVERY_N_SEC_DELAYED_DEBUG(
+        kBlockingQuiesceLogRateSeconds, "%s",
+        "Waiting for lifeguard thread to shut down");
     lifeguard_is_shut_down_->WaitForNotification();
   }
   // Do an additional wait in case this method races with LifeguardMain's
@@ -458,10 +452,9 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Lifeguard::
   // TODO(hork): new threads may spawn when there is no work in the global
   // queue, nor any work to steal. Add more sophisticated logic about when to
   // start a thread.
-  GRPC_EVENT_ENGINE_TRACE(
-      "Starting new ThreadPool thread due to backlog (total threads: %" PRIuPTR
-      ")",
-      living_thread_count + 1);
+  GRPC_TRACE_LOG(event_engine, INFO)
+      << "Starting new ThreadPool thread due to backlog (total threads: "
+      << living_thread_count + 1;
   pool_->StartThread();
   // Tell the lifeguard to monitor the pool more closely.
   backoff_.Reset();
@@ -559,8 +552,8 @@ bool WorkStealingThreadPool::ThreadState::Step() {
     // No closures were retrieved from anywhere.
     // Quit the thread if the pool has been shut down.
     if (pool_->IsShutdown()) break;
-    bool timed_out = pool_->work_signal()->WaitWithTimeout(
-        backoff_.NextAttemptTime() - grpc_core::Timestamp::Now());
+    bool timed_out =
+        pool_->work_signal()->WaitWithTimeout(backoff_.NextAttemptDelay());
     if (pool_->IsForking() || pool_->IsShutdown()) break;
     // Quit a thread if the pool has more than it requires, and this thread
     // has been idle long enough.

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h

@@ -18,6 +18,9 @@
 #ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_WORK_STEALING_THREAD_POOL_H
 #define GRPC_SRC_CORE_LIB_EVENT_ENGINE_THREAD_POOL_WORK_STEALING_THREAD_POOL_H
 
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/thd_id.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -27,19 +30,14 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/functional/any_invocable.h"
-
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/support/port_platform.h>
-#include <grpc/support/thd_id.h>
-
-#include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/event_engine/thread_pool/thread_count.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
 #include "src/core/lib/event_engine/work_queue/work_queue.h"
-#include "src/core/lib/gprpp/notification.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/time.h"
+#include "src/core/util/backoff.h"
+#include "src/core/util/notification.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -155,11 +153,7 @@ class WorkStealingThreadPool final : public ThreadPool {
     class Lifeguard {
      public:
       explicit Lifeguard(WorkStealingThreadPoolImpl* pool);
-      // Start the lifeguard thread.
-      void Start();
-      // Block until the lifeguard thread is shut down.
-      // Afterwards, reset the lifeguard state so it can start again cleanly.
-      void BlockUntilShutdownAndReset();
+      ~Lifeguard();
 
      private:
       // The main body of the lifeguard thread.
@@ -194,7 +188,8 @@ class WorkStealingThreadPool final : public ThreadPool {
     // at a time.
     std::atomic<bool> throttled_{false};
     WorkSignal work_signal_;
-    Lifeguard lifeguard_;
+    grpc_core::Mutex lifeguard_ptr_mu_;
+    std::unique_ptr<Lifeguard> lifeguard_ ABSL_GUARDED_BY(lifeguard_ptr_mu_);
     // Set of threads for verbose failure debugging
     grpc_core::Mutex thd_set_mu_;
     absl::flat_hash_set<gpr_thd_id> thds_ ABSL_GUARDED_BY(thd_set_mu_);

data/src/core/lib/event_engine/thready_event_engine/thready_event_engine.cc

@@ -14,15 +14,16 @@
 
 #include "src/core/lib/event_engine/thready_event_engine/thready_event_engine.h"
 
+#include <grpc/support/port_platform.h>
+
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <vector>
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/crash.h"
-#include "src/core/lib/gprpp/thd.h"
+#include "src/core/util/crash.h"
+#include "src/core/util/sync.h"
+#include "src/core/util/thd.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -39,20 +40,45 @@ ThreadyEventEngine::CreateListener(
     absl::AnyInvocable<void(absl::Status)> on_shutdown,
     const EndpointConfig& config,
     std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory) {
+  struct AcceptState {
+    grpc_core::Mutex mu_;
+    grpc_core::CondVar cv_;
+    int pending_accepts_ ABSL_GUARDED_BY(mu_) = 0;
+  };
+  auto accept_state = std::make_shared<AcceptState>();
   return impl_->CreateListener(
-      [this, on_accept = std::make_shared<Listener::AcceptCallback>(
-                 std::move(on_accept))](std::unique_ptr<Endpoint> endpoint,
-                                        MemoryAllocator memory_allocator) {
+      [this, accept_state,
+       on_accept = std::make_shared<Listener::AcceptCallback>(
+           std::move(on_accept))](std::unique_ptr<Endpoint> endpoint,
+                                  MemoryAllocator memory_allocator) {
+        {
+          grpc_core::MutexLock lock(&accept_state->mu_);
+          ++accept_state->pending_accepts_;
+        }
         Asynchronously(
-            [on_accept, endpoint = std::move(endpoint),
+            [on_accept, accept_state, endpoint = std::move(endpoint),
              memory_allocator = std::move(memory_allocator)]() mutable {
               (*on_accept)(std::move(endpoint), std::move(memory_allocator));
+              {
+                grpc_core::MutexLock lock(&accept_state->mu_);
+                --accept_state->pending_accepts_;
+                if (accept_state->pending_accepts_ == 0) {
+                  accept_state->cv_.Signal();
+                }
+              }
             });
       },
-      [this,
+      [this, accept_state,
        on_shutdown = std::move(on_shutdown)](absl::Status status) mutable {
-        Asynchronously([on_shutdown = std::move(on_shutdown),
+        Asynchronously([accept_state, on_shutdown = std::move(on_shutdown),
                         status = std::move(status)]() mutable {
+          while (true) {
+            grpc_core::MutexLock lock(&accept_state->mu_);
+            if (accept_state->pending_accepts_ == 0) {
+              break;
+            }
+            accept_state->cv_.Wait(&accept_state->mu_);
+          }
           on_shutdown(std::move(status));
         });
       },
@@ -85,7 +111,9 @@ bool ThreadyEventEngine::IsWorkerThread() {
 absl::StatusOr<std::unique_ptr<EventEngine::DNSResolver>>
 ThreadyEventEngine::GetDNSResolver(
     const DNSResolver::ResolverOptions& options) {
-  return std::make_unique<ThreadyDNSResolver>(*impl_->GetDNSResolver(options));
+  return std::make_unique<ThreadyDNSResolver>(
+      *impl_->GetDNSResolver(options),
+      std::static_pointer_cast<ThreadyEventEngine>(shared_from_this()));
 }
 
 void ThreadyEventEngine::Run(Closure* closure) {
@@ -116,10 +144,10 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupHostname(
     LookupHostnameCallback on_resolve, absl::string_view name,
     absl::string_view default_port) {
   return impl_->LookupHostname(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<ResolvedAddress>> addresses) mutable {
-        engine_->Asynchronously([on_resolve = std::move(on_resolve),
-                                 addresses = std::move(addresses)]() mutable {
+        engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                addresses = std::move(addresses)]() mutable {
           on_resolve(std::move(addresses));
         });
       },
@@ -129,13 +157,12 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupHostname(
 void ThreadyEventEngine::ThreadyDNSResolver::LookupSRV(
     LookupSRVCallback on_resolve, absl::string_view name) {
   return impl_->LookupSRV(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<SRVRecord>> records) mutable {
-        return engine_->Asynchronously(
-            [on_resolve = std::move(on_resolve),
-             records = std::move(records)]() mutable {
-              on_resolve(std::move(records));
-            });
+        return engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                       records = std::move(records)]() mutable {
+          on_resolve(std::move(records));
+        });
       },
       name);
 }
@@ -143,10 +170,10 @@ void ThreadyEventEngine::ThreadyDNSResolver::LookupSRV(
 void ThreadyEventEngine::ThreadyDNSResolver::LookupTXT(
     LookupTXTCallback on_resolve, absl::string_view name) {
   return impl_->LookupTXT(
-      [this, on_resolve = std::move(on_resolve)](
+      [engine = engine_, on_resolve = std::move(on_resolve)](
           absl::StatusOr<std::vector<std::string>> record) mutable {
-        return engine_->Asynchronously([on_resolve = std::move(on_resolve),
-                                        record = std::move(record)]() mutable {
+        return engine->Asynchronously([on_resolve = std::move(on_resolve),
+                                       record = std::move(record)]() mutable {
           on_resolve(std::move(record));
         });
       },