@@ -182,7 +182,7 @@ struct _xidregitem {
 PyAPI_FUNC(struct _is*) _PyInterpreterState_LookUpID(int64_t);
 
 PyAPI_FUNC(int) _PyInterpreterState_IDInitref(struct _is *);
-PyAPI_FUNC(void) _PyInterpreterState_IDIncref(struct _is *);
+PyAPI_FUNC(int) _PyInterpreterState_IDIncref(struct _is *);
 PyAPI_FUNC(void) _PyInterpreterState_IDDecref(struct _is *);
 
 #ifdef __cplusplus
 
@@ -0,0 +1,5 @@
+_PyInterpreterState_IDIncref() now calls _PyInterpreterState_IDInitref() and
+always increments id_refcount. Previously, calling
+_xxsubinterpreters.get_current() could create an id_refcount inconsistency
+when a _xxsubinterpreters.InterpreterID object was deallocated. Patch by
+Victor Stinner.
@@ -24,15 +24,21 @@ newinterpid(PyTypeObject *cls, int64_t id, int force)
         }
     }
 
+    if (interp != NULL) {
+        if (_PyInterpreterState_IDIncref(interp) < 0) {
+            return NULL;
+        }
+    }
+
     interpid *self = PyObject_New(interpid, cls);
     if (self == NULL) {
+        if (interp != NULL) {
+            _PyInterpreterState_IDDecref(interp);
+        }
         return NULL;
     }
     self->id = id;
 
-    if (interp != NULL) {
-        _PyInterpreterState_IDIncref(interp);
-    }
     return self;
 }
 
 
@@ -493,24 +493,25 @@ _PyInterpreterState_IDInitref(PyInterpreterState *interp)
 }
 
 
-void
+int
 _PyInterpreterState_IDIncref(PyInterpreterState *interp)
 {
-    if (interp->id_mutex == NULL) {
-        return;
+    if (_PyInterpreterState_IDInitref(interp) < 0) {
+        return -1;
     }
+
     PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);
     interp->id_refcount += 1;
     PyThread_release_lock(interp->id_mutex);
+    return 0;
 }
 
 
 void
 _PyInterpreterState_IDDecref(PyInterpreterState *interp)
 {
-    if (interp->id_mutex == NULL) {
-        return;
-    }
+    assert(interp->id_mutex != NULL);
+
     struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate;
     PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);
     assert(interp->id_refcount != 0);
Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,21 @@ newinterpid(PyTypeObject *cls, int64_t id, int force)`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ if (interp != NULL) {`
	`28`	`+ if (_PyInterpreterState_IDIncref(interp) < 0) {`
	`29`	`+ return NULL;`
	`30`	`+ }`
	`31`	`+ }`
	`32`	`+`
`27`	`33`	`interpid *self = PyObject_New(interpid, cls);`
`28`	`34`	`if (self == NULL) {`
	`35`	`+ if (interp != NULL) {`
	`36`	`+ _PyInterpreterState_IDDecref(interp);`
	`37`	`+ }`
`29`	`38`	`return NULL;`
`30`	`39`	`}`
`31`	`40`	`self->id = id;`
`32`	`41`
`33`		`- if (interp != NULL) {`
`34`		`- _PyInterpreterState_IDIncref(interp);`
`35`		`- }`
`36`	`42`	`return self;`
`37`	`43`	`}`
`38`	`44`
Original file line number	Diff line number	Diff line change
`@@ -493,24 +493,25 @@ _PyInterpreterState_IDInitref(PyInterpreterState *interp)`
`493`	`493`	`}`
`494`	`494`
`495`	`495`
`496`		`-void`
	`496`	`+int`
`497`	`497`	`_PyInterpreterState_IDIncref(PyInterpreterState *interp)`
`498`	`498`	`{`
`499`		`- if (interp->id_mutex == NULL) {`
`500`		`- return;`
	`499`	`+ if (_PyInterpreterState_IDInitref(interp) < 0) {`
	`500`	`+ return -1;`
`501`	`501`	`}`
	`502`	`+`
`502`	`503`	`PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);`
`503`	`504`	`interp->id_refcount += 1;`
`504`	`505`	`PyThread_release_lock(interp->id_mutex);`
	`506`	`+ return 0;`
`505`	`507`	`}`
`506`	`508`
`507`	`509`
`508`	`510`	`void`
`509`	`511`	`_PyInterpreterState_IDDecref(PyInterpreterState *interp)`
`510`	`512`	`{`
`511`		`- if (interp->id_mutex == NULL) {`
`512`		`- return;`
`513`		`- }`
	`513`	`+ assert(interp->id_mutex != NULL);`
	`514`	`+`
`514`	`515`	`struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate;`
`515`	`516`	`PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);`
`516`	`517`	`assert(interp->id_refcount != 0);`