Avoid a deadlock when issuing a request while another thread is reading events

forestbond · forestbond · commit ff79f58ee57d · 2011-07-31T19:29:44.000Z
from the server.  This occurs when both threads block on the select call but
the response has already been read by the event thread.
diff --git a/Xlib/protocol/display.py b/Xlib/protocol/display.py
@@ -371,6 +371,9 @@ def send_and_recv(self, flush = None, event = None, request = None, recv = None)
         #  If waiting for an event, we want to recv
         #  If just trying to receive anything we can, we want to recv
 
+        # FIXME: It would be good if we could also sleep when we're waiting on
+        # a response to a request that has already been sent.
+
         if (((flush or request is not None) and self.send_active)
             or ((event or recv) and self.recv_active)):
 
@@ -472,6 +475,10 @@ def send_and_recv(self, flush = None, event = None, request = None, recv = None)
             # for the network to fire up
             self.send_recv_lock.release()
 
+            # There's no longer anything useful we can do here.
+            if not (sending or recieving):
+                break
+
             # If we're flushing, figure out how many bytes we
             # have to send so that we're not caught in an interminable
             # loop if other threads continuously append requests.
diff --git a/examples/eventthread.py b/examples/eventthread.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+#
+# examples/eventthread.py -- Tests multithreaded event handling
+#
+#    Copyright (C) 2010-2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@rapidrollout.com>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import sys, time
+from threading import Thread
+
+from Xlib import X, Xatom, threaded
+from Xlib.display import Display
+
+
+class EventThread(Thread):
+    display = None
+    _stop = None
+
+    def __init__(self, display):
+        super(EventThread, self).__init__()
+        self.display = display
+        self.daemon = True
+
+    def run(self):
+        while True:
+            event = self.display.next_event()
+            print 'event: %r' % event
+
+
+def main(argv):
+    display = Display()
+
+    thread = EventThread(display)
+    thread.start()
+    time.sleep(1)
+
+    screen = display.screen()
+
+    # The get_property call should not deadlock, despite the blocking next_event
+    # call in the thread.
+    atom = display.intern_atom('_XROOTPMAP_ID', True)
+    response = screen.root.get_property(atom, Xatom.PIXMAP, 0, 1)
+    print 'get_property response: %r' % response
+
+    display.close()
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))
