bpo-45274: Fix Thread._wait_for_tstate_lock() race condition by vstinner · Pull Request #28532 · python/cpython (original) (raw)
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service andprivacy statement. We’ll occasionally send you account related emails.
Already on GitHub?Sign in to your account
Conversation11 Commits1 Checks0 Files changed
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
[ Show hidden characters]({{ revealButtonHref }})
Fix a race condition in the Thread.join() method of the threading
module. If the function is interrupted by a signal and the signal
handler raises an exception, make sure that the thread remains in a
consistent state to prevent a deadlock.
https://bugs.python.org/issue45274
Fix a race condition in the Thread.join() method of the threading module. If the function is interrupted by a signal and the signal handler raises an exception, make sure that the thread remains in a consistent state to prevent a deadlock.
| # was interrupted with an exception before reaching the |
|---|
| # lock.release(). It can happen if a signal handler raises an |
| # exception, like CTRL+C which raises KeyboardInterrupt. |
| lock.release() |
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I don't think that this code is 100% reliable if lock.release() gets interrupted by a second exception (ex: raised by a second signal: fatality!). Maybe a context manager could be used. But I'm exhausted, I will think about this code after a good night :-)
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I believe we've still got bugs in the context manager exit implementation where even it can miss something in this scenario and not call __exit__. https://bugs.python.org/issue29988
This came up during the dev sprint in 2017 when working on the interpreter loop.
So this PR, while not technically a fix, is at least an improvement and should help the single Ctrl-C KeyboardInterrupt case.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
The whole function should be reimplemented in C to better control how signals are handled.
In pure Python, I don't think that it's possible to fully control handle any possible exception at any line number.
@serhiy-storchaka proposed to rewrite acquire()+release() in C to make sure that at least the lock remains consistent: https://bugs.python.org/issue45274#msg402532 So it doesn't handle exceptions in the _stop() method.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
But I only wanted to enhance the code, I'm not interested to rewrite threading.Thread in C.
cc @pablogsal @ambv @corona10 @serhiy-storchaka: Here is an interesting race condition in the threading module ;-) Making sure that we restore the Thread object in a consistent state is challenging. My fix should make these code less bad (more reliable, but not 100% reliable).
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I would prefer to devise some general solution to this, maybe adding some private method in C but I am ok with this solution for the time being.
Thanks @vstinner for the PR 🌮🎉.. I'm working now to backport this PR to: 3.9.
🐍🍒⛏🤖
Thanks @vstinner for the PR 🌮🎉.. I'm working now to backport this PR to: 3.10.
🐍🍒⛏🤖
miss-islington pushed a commit to miss-islington/cpython that referenced this pull request
Fix a race condition in the Thread.join() method of the threading module. If the function is interrupted by a signal and the signal handler raises an exception, make sure that the thread remains in a consistent state to prevent a deadlock. (cherry picked from commit a22be49)
Co-authored-by: Victor Stinner vstinner@python.org
miss-islington pushed a commit to miss-islington/cpython that referenced this pull request
Fix a race condition in the Thread.join() method of the threading module. If the function is interrupted by a signal and the signal handler raises an exception, make sure that the thread remains in a consistent state to prevent a deadlock. (cherry picked from commit a22be49)
Co-authored-by: Victor Stinner vstinner@python.org
miss-islington added a commit that referenced this pull request
Fix a race condition in the Thread.join() method of the threading module. If the function is interrupted by a signal and the signal handler raises an exception, make sure that the thread remains in a consistent state to prevent a deadlock. (cherry picked from commit a22be49)
Co-authored-by: Victor Stinner vstinner@python.org
vstinner added a commit that referenced this pull request
… (GH-28580)
Fix a race condition in the Thread.join() method of the threading module. If the function is interrupted by a signal and the signal handler raises an exception, make sure that the thread remains in a consistent state to prevent a deadlock. (cherry picked from commit a22be49)
Co-authored-by: Victor Stinner vstinner@python.org