add python implementation

Author: eendebakpt

Lib/threading.py

@@ -8,6 +8,7 @@
 from time import monotonic as _time
 from _weakrefset import WeakSet
 from itertools import count as _count
+from collections.abc import Iterator
 try:
     from _collections import deque as _deque
 except ImportError:
@@ -42,7 +43,6 @@
 get_ident = _thread.get_ident
 _get_main_thread_ident = _thread._get_main_thread_ident
 _is_main_interpreter = _thread._is_main_interpreter
-iter_locked = _thread.iter_locked
 try:
     get_native_id = _thread.get_native_id
     _HAVE_THREAD_NATIVE_ID = True
@@ -1633,3 +1633,13 @@ def _after_fork():
 
 if hasattr(_os, "register_at_fork"):
     _os.register_at_fork(after_in_child=_after_fork)
+
+class iter_locked(Iterator):
+    def __init__(self, it):
+        """Convert an iterable into an iterator that performs iteration using locks """
+        self._it = iter(it)
+        self._lock = RLock()
+
+    def __next__(self):
+        with self._lock:
+            return next(self._it)

Modules/_threadmodule.c

@@ -27,7 +27,6 @@ static struct PyModuleDef thread_module;
 // Module state
 typedef struct {
     PyTypeObject *excepthook_type;
-    PyTypeObject *iter_locked_type;
     PyTypeObject *lock_type;
     PyTypeObject *rlock_type;
     PyTypeObject *local_type;
@@ -69,7 +68,6 @@ static PF_SET_THREAD_DESCRIPTION pSetThreadDescription = NULL;
 
 /*[clinic input]
 module _thread
-class _thread.iter_locked "iter_locked_object *" "clinic_state()->iter_locked_type"
 class _thread.lock "lockobject *" "clinic_state()->lock_type"
 class _thread.RLock "rlockobject *" "clinic_state()->rlock_type"
 
@@ -754,101 +752,6 @@ static PyType_Spec ThreadHandle_Type_spec = {
     ThreadHandle_Type_slots,
 };
 
-/* iter_locked object **************************************************************/
-
-typedef struct {
-    PyObject_HEAD
-    PyObject *it;
-    _PyRecursiveMutex lock;
-} iter_locked_object;
-
-#define iter_locked_object_CAST(op)    ((iter_locked_object *)(op))
-
-/*[clinic input]
-@classmethod
-_thread.iter_locked.__new__
-    iterable: object
-    /
-Make an iterator thread-safe.
-[clinic start generated code]*/
-
-static PyObject *
-_thread_iter_locked_impl(PyTypeObject *type, PyObject *iterable)
-/*[clinic end generated code: output=4a8ad5a25f7c09ba input=ae6124177726e809]*/
-{
-    /* Get iterator. */
-    PyObject *it = PyObject_GetIter(iterable);
-    if (it == NULL)
-        return NULL;
-
-    iter_locked_object *il = (iter_locked_object *)type->tp_alloc(type, 0);
-    if (il == NULL) {
-        Py_DECREF(it);
-        return NULL;
-    }
-    il->it = it;
-    il->lock = (_PyRecursiveMutex){0};
-
-    return (PyObject *)il;
-}
-
-static void
-iter_locked_dealloc(PyObject *op)
-{
-    iter_locked_object *il = iter_locked_object_CAST(op);
-    PyTypeObject *tp = Py_TYPE(il);
-    PyObject_GC_UnTrack(il);
-    Py_DECREF(il->it);
-    tp->tp_free(il);
-    Py_DECREF(tp);
-}
-
-static int
-iter_locked_traverse(PyObject *op, visitproc visit, void *arg)
-{
-    iter_locked_object *lz = iter_locked_object_CAST(op);
-    Py_VISIT(Py_TYPE(lz));
-    Py_VISIT(lz->it);
-    return 0;
-}
-
-static PyObject *
-iter_locked_next(PyObject *op)
-{
-    iter_locked_object *lz = iter_locked_object_CAST(op);
-    PyObject *result = NULL;
-
-    _PyRecursiveMutex_Lock(&(lz->lock));
-
-    int v = PyIter_NextItem(lz->it, &result);
-    if (v == -1) {
-        /* Note:  StopIteration is already cleared by PyIter_Next() */
-        /* If PyErr_Occurred() we will also return NULL*/
-    }
-    _PyRecursiveMutex_Unlock(&(lz->lock));
-
-    return result;
-}
-
-static PyType_Slot iter_locked_slots[] = {
-    {Py_tp_dealloc, iter_locked_dealloc},
-    {Py_tp_getattro, PyObject_GenericGetAttr},
-    {Py_tp_doc, (void *)_thread_iter_locked__doc__},
-    {Py_tp_traverse, iter_locked_traverse},
-    {Py_tp_iter, PyObject_SelfIter},
-    {Py_tp_iternext, iter_locked_next},
-    {Py_tp_new, _thread_iter_locked},
-    {Py_tp_free, PyObject_GC_Del},
-    {0, NULL},
-};
-
-static PyType_Spec iter_locked_spec = {
-    .name = "threading.iter_locked",
-    .basicsize = sizeof(iter_locked_object),
-    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE |
-              Py_TPFLAGS_IMMUTABLETYPE),
-    .slots = iter_locked_slots,
-};
 
 /* Lock objects */
 
@@ -2759,15 +2662,6 @@ thread_module_exec(PyObject *module)
         return -1;
     }
 
-    // iter_locked
-    state->iter_locked_type = (PyTypeObject *)PyType_FromModuleAndSpec(module, &iter_locked_spec, NULL);
-    if (state->iter_locked_type == NULL) {
-        return -1;
-    }
-    if (PyModule_AddType(module, state->iter_locked_type) < 0) {
-        return -1;
-    }
-
     // Lock
     state->lock_type = (PyTypeObject *)PyType_FromModuleAndSpec(module, &lock_type_spec, NULL);
     if (state->lock_type == NULL) {
@@ -2874,7 +2768,6 @@ thread_module_traverse(PyObject *module, visitproc visit, void *arg)
 {
     thread_module_state *state = get_thread_state(module);
     Py_VISIT(state->excepthook_type);
-    Py_VISIT(state->iter_locked_type);
     Py_VISIT(state->lock_type);
     Py_VISIT(state->rlock_type);
     Py_VISIT(state->local_type);
@@ -2888,7 +2781,6 @@ thread_module_clear(PyObject *module)
 {
     thread_module_state *state = get_thread_state(module);
     Py_CLEAR(state->excepthook_type);
-    Py_CLEAR(state->iter_locked_type);
     Py_CLEAR(state->lock_type);
     Py_CLEAR(state->rlock_type);
     Py_CLEAR(state->local_type);