Even with this PR thezip function is not thread-safe: when iterating overzip(range(100), range(100)) one can obtain a tuple(2,3). What does PR (hopefully) does is modifying the code so that the interpreter does not crash. For this reason I would like to be careful with the term "thread-safe". I choose not to makezip fully thread safe because of the performance impact, see the discussion in#120496

Thanks for clarifying. The wordsafe is a bit confusing, I guess a lot of other people would read it asthread-safe. I think we need to clarify the reason whyzip isn't safe infree-threaded build.

I think we want to enable re-use under certain conditions. We should probably put the logic in some internal function, possibly inpycore_object.h. I think the condition for the free-threaded build is:

1. ob_tid matches_Py_ThreadId()
2. ob_ref_local is 1
3. ob_ref_shared is 0

The logic is that no other thread callingzip_next can re-uselz->result because of the thread id condition (condition 1). And no thread outside ofzip_next can incref that object because the combined conditions ensure thatlz->result is the only reference.

@colesbury Thanks for the hint! I implementeded the suggestion

• I placed the logic in a single method_Py_Reuse_Immutable_Object so we can use the trick code for several other cases (e.g.itertools.pairwise,enumerate). The location and name of the new method can be changed though
• I re-ordered the three conditions because I suspect thatob_ref_local is most informative and fastest to check
• I am now checkingob_ref_shared to be zero, but perhaps we should check onPy_ARITHMETIC_RIGHT_SHIFT(Py_ssize_t, ob_ref_shared , _Py_REF_SHARED_SHIFT)?

The preferred style is to usefor loops instead of using list comprehensions for side effects.

We run lots of unit tests in CI, so they individually need to be very fast. For the free-threaded tests, we should aim for <0.1 seconds on two cores (i.e., when run withtaskset -c 0-1 on Linux)

On my system (windows) the test is 0.07 seconds for the free-threading build. I will reduce the number of threads and iterations a bit so it is even faster.