Crash when using typing and daemon threads

[nineteendo]

Crash report

What happened?

When I run this code on Python 3.11 it runs fine, but if I import typing_minimal (or typing) in reader.py I get this error:

Fatal Python error: _enter_buffered_busy: could not acquire lock for <_io.BufferedReader name='<stdin>'> at interpreter shutdown, possibly due to daemon threads
Python runtime state: finalizing (tstate=0x00007fff13ab6960)

Current thread 0x00003944 (most recent call first):
 <no Python frame>

main.py:

import reader
from typing_minimal import Generic, TypeVar

VALUE = TypeVar("VALUE")


class BaseClass(Generic[VALUE]):
 def __init__(self):
 pass


class SubClass(BaseClass[VALUE]):
 pass


reader.thread.start()

reader.py:

from sys import stdin
from threading import Thread

# BUG: I get an error when I assign this:
# typing_minimal = __import__("typing_minimal")


thread = Thread(target=lambda: stdin.buffer.read(), daemon=True)

typing_minimal.py:

from functools import lru_cache, wraps


def _tp_cache(func):
 cached = lru_cache()(func)

 @wraps(func)
 def inner(*args, **kwds):
 return cached(*args, **kwds)

 return inner


class TypeVar:
 def __init__(self, _):
 pass


class _GenericAlias:
 def __init__(self, origin):
 self.origin = origin

 def __eq__(self, other):
 if isinstance(other, _GenericAlias):
 return self.origin is other.origin

 return NotImplemented

 def __hash__(self):
 return hash(self.origin)

 def __mro_entries__(self, _):
 return (self.origin,)


class Generic:
 @_tp_cache
 def __class_getitem__(cls, *_):
 return _GenericAlias(cls)

I don't understand how this is even possible.

CPython versions tested on:

3.11

Operating systems tested on:

macOS, Windows

[sobolevn]

_lru_cache_wrapper uses RLock() inside, so this might be the cause when combined with a daemon thread.

[JelleZijlstra]

What is typing_minimal here? That's not in the stdlib and a cursory Google search didn't turn up anything.

[sobolevn]

It is a simplification of typing.py to make the bug more obvious :)

[JelleZijlstra]

It's in the comment... sorry I missed that.

[nineteendo]

Any idea why importing typing_minimal in reader.py makes a difference?
__import__("typing_minimal") instead of typing_minimal = __import__("typing_minimal") works fine though.

[JelleZijlstra]

Possibly some new reference cycle gets created. Reminds me of #115874 though the symptom is different.

[nineteendo]

Is there anything I can still help with?

[sobolevn]

I used this example to reproduce the issue:

from sys import stdin
from threading import Thread


def start_reading():
 Thread(target=stdin.buffer.read, daemon=True).start()

start_reading()

It still gives me:

» ./python.exe main.py
Fatal Python error: _enter_buffered_busy: could not acquire lock for <_io.BufferedReader name='<stdin>'> at interpreter shutdown, possibly due to daemon threads
Python runtime state: finalizing (tstate=0x000000010553bdd8)

Current thread 0x00000001e4b85300 (most recent call first):
 <no Python frame>
[1] 92981 abort ./python.exe main.py
 

So, now I think that this is a related to #113964

[nineteendo]

The code at the top is simplified as much as possible. So this doesn't result in an error without the other changes (which is kind of strange too):

from sys import stdin
from threading import Thread


def read():
 stdin.buffer.read()


Thread(target=read, daemon=True).start()

[nineteendo]

This issue isn't so much about the interpreter crashing, but the fact that it crashes when I import typing_minimal in reader.py.

[nineteendo]

I'm closing this, as it's an obscure edge case. If anyone wants to look into this, this can be reopened.

[JelleZijlstra]

It's a crash so it should be fixed. Hopefully someone will come along eventually and fix it, or other changes to the interpreter will fix this issue.