Function drainWorkerThreads

worker.go:178–231

()

}

func drainWorkerThreads() (drainedThreads []*phpThread) {
	var ready sync.WaitGroup

	for _, worker := range workers {
		worker.threadMutex.RLock()
		ready.Add(len(worker.threads))

		for _, thread := range worker.threads {
			if !thread.state.RequestSafeStateChange(state.Restarting) {
				ready.Done()

				// no state change allowed == thread is shutting down
				// we'll proceed to restart all other threads anyway
				continue
			}

			thread.handler.drain()
			close(thread.drainChan)
			drainedThreads = append(drainedThreads, thread)

			go func(thread *phpThread) {
				thread.state.WaitFor(state.Yielding, state.ShuttingDown, state.Done)
				ready.Done()
			}(thread)
		}

		worker.threadMutex.RUnlock()
	}

	done := make(chan struct{})
	go func() {
		ready.Wait()
		close(done)
	}()

	select {
	case <-done:
	case <-time.After(drainGracePeriod):
		// Force-kill any thread still stuck in a blocking syscall, then
		// keep waiting unconditionally. On platforms where force-kill
		// cannot interrupt the syscall (macOS, Windows non-alertable
		// Sleep) the thread exits when the syscall completes naturally.
		for _, thread := range drainedThreads {
			if !thread.state.Is(state.Yielding) {
				thread.forceKillMu.RLock()
				C.frankenphp_force_kill_thread(thread.forceKill)
				thread.forceKillMu.RUnlock()
			}
		}
		<-done
	}

	return drainedThreads
}

// RestartWorkers attempts to restart all workers gracefully.
// All workers must be restarted at the same time to prevent issues with