Fix channel cleanup by closing streams before stopping ioloop thread (#1089)

* Fix channel cleanup by closing streams before stopping ioloop thread

The change in PR #1076 added 'finally: loop.close()' to IOLoopThread.run(),
which closes the asyncio event loop before ZMQ streams have been properly
unregistered. This caused errors during teardown when downstream projects
like qtconsole tried to check if channels were closed.

The fix ensures that channel streams are explicitly closed (via close())
while the ioloop is still running, before calling stop_channels() on the
parent class and stopping the ioloop thread. This allows the ZMQ streams
to be properly unregistered from the event loop before it's closed.

* Fix _exiting to be instance variable, not shared class variable

The _exiting flag was defined as a class variable, meaning when one
IOLoopThread called stop() and set _exiting = True, it affected ALL
IOLoopThread instances. This caused subsequent kernels to fail to start
because _async_run() would immediately exit.

By initializing self._exiting = False in __init__, each IOLoopThread
instance now has its own exit flag. The class-level _exiting is still
used by _notice_exit() for interpreter shutdown cleanup.

Author: rgbkrk

jupyter_client/threaded.py

@@ -230,6 +230,13 @@ def __init__(self) -> None:
         super().__init__()
         self.daemon = True
 
+        # Instance variable to track exit state for this specific thread.
+        # The class variable _exiting is used by _notice_exit for interpreter shutdown.
+        # Without this instance variable, stopping one IOLoopThread sets the class-level
+        # _exiting = True, causing all subsequent IOLoopThread instances to exit immediately
+        # in _async_run(). This breaks sequential kernel usage (e.g., qtconsole tests).
+        self._exiting = False
+
     @staticmethod
     @atexit.register
     def _notice_exit() -> None:
@@ -333,6 +340,19 @@ def _check_kernel_info_reply(self, msg: dict[str, Any]) -> None:
 
     def stop_channels(self) -> None:
         """Stop the channels on the client."""
+        # Close channel streams while ioloop is still running
+        # This must happen before stopping the ioloop thread, otherwise
+        # the ZMQ streams can't be properly unregistered from the event loop
+        if self.ioloop_thread and self.ioloop_thread.is_alive():
+            if self._shell_channel is not None:
+                self._shell_channel.close()
+            if self._iopub_channel is not None:
+                self._iopub_channel.close()
+            if self._stdin_channel is not None:
+                self._stdin_channel.close()
+            if self._control_channel is not None:
+                self._control_channel.close()
+
         super().stop_channels()
         if self.ioloop_thread and self.ioloop_thread.is_alive():
             self.ioloop_thread.stop()