diff --git a/Lib/idlelib/PyShell.py b/Lib/idlelib/PyShell.py
index 0c9fbfb..9f158f5 100644
--- a/Lib/idlelib/PyShell.py
+++ b/Lib/idlelib/PyShell.py
@@ -367,18 +367,14 @@
             except:
                 pass
         # Kill subprocess, spawn a new one, accept connection.
-        if hasattr(os, 'kill'):
-            # We can interrupt any loop if we can use SIGINT. This doesn't
-            # work in Windows, currently we can only interrupt loops doing I/O.
-            self.__signal_interrupt()
-        # XXX KBK 13Feb03 Don't close the socket until the interrupt thread
-        # finishes.
-        self.tkconsole.executing = False
         try:
+            self.interrupt_subprocess()
+            self.shutdown_subprocess()
             self.rpcclt.close()
             os.wait()
         except:
             pass
+        self.tkconsole.executing = False
         self.spawn_subprocess()
         self.rpcclt.accept()
         self.transfer_path()
@@ -406,16 +402,32 @@
             pass
 
     def __request_interrupt(self):
-        self.rpcclt.asynccall("exec", "interrupt_the_server", (), {})
+        try:
+            self.rpcclt.asynccall("exec", "interrupt_the_server", (), {})
+        except:
+            pass
 
     def interrupt_subprocess(self):
-        if hasattr(os, "kill"):
+        # XXX KBK 22Mar03 Use interrupt message on all platforms for now.
+        # XXX if hasattr(os, "kill"):
+        if False:
             self.__signal_interrupt()
         else:
             # Windows has no os.kill(), use an RPC message.
             # This is async, must be done in a thread.
             threading.Thread(target=self.__request_interrupt).start()
 
+    def __request_shutdown(self):
+        try:
+            self.rpcclt.asynccall("exec", "shutdown_the_server", (), {})
+        except:
+            pass
+
+    def shutdown_subprocess(self):
+        t = threading.Thread(target=self.__request_shutdown)
+        t.start()
+        t.join()
+
     def transfer_path(self):
         self.runcommand("""if 1:
         import sys as _sys
@@ -468,9 +480,10 @@
 
     def kill_subprocess(self):
         clt = self.rpcclt
-        self.rpcclt = None
         if clt is not None:
+            self.shutdown_subprocess()
             clt.close()
+        self.rpcclt = None
 
     debugger = None
 
diff --git a/Lib/idlelib/run.py b/Lib/idlelib/run.py
index d79f3d7..497cbbd 100644
--- a/Lib/idlelib/run.py
+++ b/Lib/idlelib/run.py
@@ -2,6 +2,8 @@
 import time
 import socket
 import traceback
+import threading
+import Queue
 
 import boolcheck
 
@@ -10,9 +12,20 @@
 import RemoteObjectBrowser
 import StackViewer
 import rpc
+import interrupt
 
 import __main__
 
+# Thread shared globals: Establish a queue between a subthread (which handles
+# the socket) and the main thread (which runs user code), plus global
+# completion and exit flags:
+
+server = None                # RPCServer instance
+queue = Queue.Queue(0)
+execution_finished = False
+exit_requested = False
+
+
 def main():
     """Start the Python execution server in a subprocess
 
@@ -20,7 +33,7 @@
     MyHandler, which inherits register/unregister methods from RPCHandler via
     the mix-in class SocketIO.
 
-    When the RPCServer svr is instantiated, the TCPServer initialization
+    When the RPCServer 'server' is instantiated, the TCPServer initialization
     creates an instance of run.MyHandler and calls its handle() method.
     handle() instantiates a run.Executive object, passing it a reference to the
     MyHandler object.  That reference is saved as attribute rpchandler of the
@@ -31,15 +44,35 @@
     register and unregister themselves.
 
     """
+    global queue, execution_finished, exit_requested
+
     port = 8833
     if sys.argv[1:]:
         port = int(sys.argv[1])
     sys.argv[:] = [""]
-    addr = ("localhost", port)
+    sockthread = threading.Thread(target=manage_socket,
+                                  name='SockThread',
+                                  args=(('localhost', port),))
+    sockthread.setDaemon(True)
+    sockthread.start()
+    while 1:
+        try:
+            if exit_requested:
+                sys.exit()
+            # XXX KBK 22Mar03 eventually check queue here!
+            pass
+            time.sleep(0.05)
+        except KeyboardInterrupt:
+            ##execution_finished = True
+            continue
+
+def manage_socket(address):
+    global server, exit_requested
+
     for i in range(6):
         time.sleep(i)
         try:
-            svr = rpc.RPCServer(addr, MyHandler)
+            server = rpc.RPCServer(address, MyHandler)
             break
         except socket.error, err:
             if i < 3:
@@ -49,18 +82,21 @@
                                               + err[1] + ", retrying...."
     else:
         print>>sys.__stderr__, "\nConnection to Idle failed, exiting."
-        sys.exit()
-    svr.handle_request() # A single request only
+        exit_requested = True
+    server.handle_request() # A single request only
+
 
 class MyHandler(rpc.RPCHandler):
 
     def handle(self):
+        """Override base method"""
         executive = Executive(self)
         self.register("exec", executive)
         sys.stdin = self.get_remote_proxy("stdin")
         sys.stdout = self.get_remote_proxy("stdout")
         sys.stderr = self.get_remote_proxy("stderr")
-        rpc.RPCHandler.handle(self)
+        rpc.RPCHandler.getresponse(self, myseq=None, wait=0.5)
+
 
 class Executive:
 
@@ -70,6 +106,25 @@
         self.calltip = CallTips.CallTips()
 
     def runcode(self, code):
+        global queue, execution_finished
+
+        execution_finished = False
+        queue.put(code)
+        # dequeue and run in subthread
+        self.runcode_from_queue()
+        while not execution_finished:
+            time.sleep(0.05)
+
+    def runcode_from_queue(self):
+        global queue, execution_finished
+
+        # poll until queue has code object, using threads, just block?
+        while True:
+            try:
+                code = queue.get(0)
+                break
+            except Queue.Empty:
+                time.sleep(0.05)
         try:
             exec code in self.locals
         except:
@@ -85,7 +140,10 @@
             lines = traceback.format_exception_only(typ, val)
             for line in lines:
                 print>>efile, line,
-        self.flush_stdout()
+            execution_finished = True
+        else:
+            self.flush_stdout()
+            execution_finished = True
 
     def flush_stdout(self):
         try:
@@ -126,9 +184,14 @@
             tb[i] = fn, ln, nm, line
 
     def interrupt_the_server(self):
-        # XXX KBK 05Feb03 Windows requires this be done with messages and
-        #                 threads....
         self.rpchandler.interrupted = True
+        ##print>>sys.__stderr__, "** Interrupt main!"
+        interrupt.interrupt_main()
+
+    def shutdown_the_server(self):
+        global exit_requested
+
+        exit_requested = True
 
     def start_the_debugger(self, gui_adap_oid):
         return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)