tree 22e64db07e0431082fd8d9b8dc231d06347d81c6
parent 985dd8e17b55ae35fc31546384fc9364f2f59f86
author Eric Snow <ericsnowcurrently@gmail.com> 1721069363 -0600
committer GitHub <noreply@github.com> 1721069363 -0600
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsFcBAABCAAQBQJmlW8zCRC1aQ7uu5UhlAAAX9UQAJqfc5aDa2s8p0KWqO4mcWod
 e7k8a+Qs2AroTJ02Vxh7huipiOa32J/K+C8zLyGBMA92QVkPjr8Jt+XFa3FKWF4K
 EDBUwKMEAZldIBWI7yS1GhpaFWUCm5qfU4o1JvVTnJ2Y4HlYxyeL1Kf8CNkYq7kT
 1TR0Qiq7CggcNgFzaYH8bIbrmz5MPtaq2Hufl+PER+5VO/sJavfUoeWcUJTg23Ht
 WCbxvZt4tEMQy6WXzZRDdfekqtVxIybmWJX0XTjwPcq6tGVefJ/GCl/4gSLcsysN
 eBeBfKl1WfmPCZF9NRhC7+5X/Kv0Z+M/4Lle3Ked+RmlQDh07f7BNC56U0N4wSm4
 6J3QKFROaItukFovUSV3b8rrwQ3CLM2bTAcSyNuJIxw0lyIa4d9hnaRHfPCJncpt
 OmuimyxUXJZEod5gY87Hot4r6zYTaek44z8z9RNv3NVocLLtSDHOqWhWmlZJbGdz
 qUIdrarevsQw7veR0pz/6aZKu3/qIsrIQs0kt6QLlm9uYY/MKi/0+UbqNlorBKFI
 Kl/8R7CYPa9WfUzxl915jbtOBsDcmXaZ/UyyTSvmblGoTfRN9tFaiHMaPAXqzIt3
 DKXGGuzTEIJTv8mCn41gFjDXyAugI2amVo+o60KMfr6JJYgIj9DeBmGRGL1n9UGw
 o1I2Wp8USHiLlIPpgYUA
 =Uw7a
 -----END PGP SIGNATURE-----
 

gh-76785: Expand How Interpreter Queues Handle Interpreter Finalization (gh-116431)

Any cross-interpreter mechanism for passing objects between interpreters must be very careful to respect isolation, even when the object is effectively immutable (e.g. int, str).  Here this especially relates to when an interpreter sends one of its objects, and then is destroyed while the inter-interpreter machinery (e.g. queue) still holds a reference to the object.

When I added interpreters.Queue, I dealt with that case (using an atexit hook) by silently removing all items from the queue that were added by the finalizing interpreter.

Later, while working on concurrent.futures.InterpreterPoolExecutor (gh-116430), I noticed it was somewhat surprising when items were silently removed from the queue when the originating interpreter was destroyed.  (See my comment on that PR.) 
 It took me a little while to realize what was going on.  I expect that users, which much less context than I have, would experience the same pain.

My approach, here, to improving the situation is to give users three options:

1. return a singleton (interpreters.queues.UNBOUND) from Queue.get() in place of each removed item
2. raise an exception (interpreters.queues.ItemInterpreterDestroyed) from Queue.get() in place of each removed item
3. existing behavior: silently remove each item (i.e. Queue.get() skips each one)

The default will now be (1), but users can still explicitly opt in any of them, including to the silent removal behavior.

The behavior for each item may be set with the corresponding Queue.put() call. and a queue-wide default may be set when the queue is created.  (This is the same as I did for "synconly".)