Fix: Replace Process.waitUntilExit() with DispatchGroup to prevent hangs #86
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
HT154
approved these changes
Nov 19, 2025
Contributor
HT154
left a comment
HT154
left a comment
There was a problem hiding this comment.
Thanks for the fix. This is good to merge after a make swiftformat.
The forum thread is a great resource, thanks for linking it!
The waitUntilExit() call was causing hangs when invoked from Swift concurrency's cooperative thread pool. This is because waitUntilExit() runs the current thread's runloop in NSDefaultRunLoopMode while waiting, which can cause unexpected behavior when called from arbitrary threads or thread pool contexts. The issue occurs because: 1. waitUntilExit() runs the runloop in default mode, allowing timers and callbacks to fire unexpectedly (see Mike Ash's article on dangerous Cocoa calls) 2. Swift concurrency's cooperative thread pool doesn't guarantee which thread executes a given task, making runloop-dependent APIs unreliable 3. The runloop may not be properly configured on thread pool threads The fix uses a DispatchGroup that is entered before starting the process and left in the process's terminationHandler. The close() method then calls wait() on the group, which is a simple blocking call without runloop involvement. This approach is safe because: - It doesn't depend on runloop infrastructure - It works correctly regardless of which thread it's called from - It provides clean synchronization with process termination References: - https://stackoverflow.com/questions/34996937/how-to-safely-use-nstask-waituntilexit-off-the-main-thread - https://mikeash.com/pyblog/friday-qa-2009-11-13-dangerous-cocoa-calls.html
johnliedtke
force-pushed
the
john/bugfix/waitforexit-fix
branch
from
fedcbc7 to
b66032f
Compare
Contributor
Author
Nice, thank you! Ran |
bioball
pushed a commit
that referenced
this pull request
Nov 20, 2025
…ngs (#86) The waitUntilExit() call was causing hangs when invoked from Swift concurrency's cooperative thread pool. This is because waitUntilExit() runs the current thread's runloop in NSDefaultRunLoopMode while waiting, which can cause unexpected behavior when called from arbitrary threads or thread pool contexts. The issue occurs because: 1. waitUntilExit() runs the runloop in default mode, allowing timers and callbacks to fire unexpectedly (see Mike Ash's article on dangerous Cocoa calls) 2. Swift concurrency's cooperative thread pool doesn't guarantee which thread executes a given task, making runloop-dependent APIs unreliable 3. The runloop may not be properly configured on thread pool threads The fix uses a DispatchGroup that is entered before starting the process and left in the process's terminationHandler. The close() method then calls wait() on the group, which is a simple blocking call without runloop involvement. This approach is safe because: - It doesn't depend on runloop infrastructure - It works correctly regardless of which thread it's called from - It provides clean synchronization with process termination References: - https://stackoverflow.com/questions/34996937/how-to-safely-use-nstask-waituntilexit-off-the-main-thread - https://mikeash.com/pyblog/friday-qa-2009-11-13-dangerous-cocoa-calls.html
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Description
I've been running into hangs with
waitUntilExit()in my CLI, which is annoying since we use it in pre-commit hooks :DThe issue is that
waitUntilExit()runs the current thread's runloop inNSDefaultRunLoopModewhile waiting for the process to exit. This causes problems with Swift concurrency's cooperative thread pool because:Basically,
waitUntilExit()assumes you're on a specific thread with a well-behaved runloop (like the main thread), but Swift concurrency doesn't give you those guarantees.The Fix
I replaced
waitUntilExit()with aDispatchGroup:terminationHandlerwait()inclose()to block until terminationThis is a simple blocking wait that doesn't depend on runloop infrastructure, so it works reliably regardless of which thread it's called from.
Ironically, I hit this same issue in my own code and solved it with Eskimo's advice, but that approach would've required a bigger refactor here. This minimal change resolves the hanging issue.
See also: Mike Ash's article on dangerous Cocoa calls