title: Sending data through a socket from another thread does not work in Python
body: <p>This is my 'game server'. It's nothing serious, I thought this was a nice way of learning a few things about python and sockets.</p>
  
  <p>First the server class initialized the server.
  Then, when someone connects, we create a client thread. In this thread we continually listen on our socket.</p>
  
  <p>Once a certain command comes in (I12345001001, for example) it spawns another thread.</p>
  
  <p>The purpose of this last thread is to send updates to the client.
  But even though I see the server is performing this code, the data isn't actually being sent.</p>
  
  <p>Could anyone tell where it's going wrong?
  It's like I have to receive something before I'm able to send. So I guess somewhere I'm missing something</p>
  
  <pre><code>
  #!/usr/bin/env python
  
  """
  An echo server that uses threads to handle multiple clients at a time.
  Entering any line of input at the terminal will exit the server.
  """
  
  import select
  import socket
  import sys
  import threading
  import time
  import Queue
  
  globuser = {}
  queue = Queue.Queue()
  
  class Server:
      def __init__(self):
          self.host = ''
          self.port = 2000
          self.backlog = 5
          self.size = 1024
          self.server = None
          self.threads = []
  
      def open_socket(self):
          try:
              self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
              self.server.bind((self.host,self.port))
              self.server.listen(5)
          except socket.error, (value,message):
              if self.server:
                  self.server.close()
              print "Could not open socket: " + message
              sys.exit(1)
  
      def run(self):
          self.open_socket()
          input = [self.server,sys.stdin]
          running = 1
          while running:
              inputready,outputready,exceptready = select.select(input,[],[])
  
              for s in inputready:
  
                  if s == self.server:
                      # handle the server socket
                      c = Client(self.server.accept(), queue)
                      c.start()
                      self.threads.append(c)
  
                  elif s == sys.stdin:
                      # handle standard input
                      junk = sys.stdin.readline()
                      running = 0
  
          # close all threads
  
          self.server.close()
          for c in self.threads:
              c.join()
  
  class Client(threading.Thread):
      initialized=0
  
      def __init__(self,(client,address), queue):
          threading.Thread.__init__(self)
          self.client = client
          self.address = address
          self.size = 1024
          self.queue = queue
          print 'Client thread created!'
  
  
      def run(self):
          running = 10
          isdata2=0
          receivedonce=0
  
          while running > 0:
  
              if receivedonce == 0:
                  print 'Wait for initialisation message'
                  data = self.client.recv(self.size)
                  receivedonce = 1
  
              if self.queue.empty():
                  print 'Queue is empty'
              else:
                  print 'Queue has information'
                  data2 = self.queue.get(1, 1)
                  isdata2 = 1
                  if data2 == 'Exit':
                      running = 0
                      print 'Client is being closed'
                      self.client.close()
  
              if data:
                  print 'Data received through socket! First char: "' + data[0] + '"'
                  if data[0] == 'I':
                      print 'Initializing user'
                      user = {'uid': data[1:6] ,'x': data[6:9], 'y': data[9:12]}
                      globuser[user['uid']] = user
                      print globuser
                      initialized=1
                      self.client.send('Beginning - Initialized'+';')
                      m=updateClient(user['uid'], queue)
                      m.start()
                  else:
                      print 'Reset receivedonce'
                      receivedonce = 0
  
                  print 'Sending client data'
                  self.client.send('Feedback: ' +data+';')
                  print 'Client Data sent: ' + data
  
              data=None
  
              if isdata2 == 1:
                  print 'Data2 received: ' + data2
                  self.client.sendall(data2)
                  self.queue.task_done()
                  isdata2 = 0
  
              time.sleep(1)
              running = running - 1
  
          print 'Client has stopped'
  
  
  class updateClient(threading.Thread):
  
      def __init__(self,uid, queue):
          threading.Thread.__init__(self)
          self.uid = uid
          self.queue = queue
          global globuser
          print 'updateClient thread started!'
  
      def run(self):
          running = 20
          test=0
          while running > 0:
              test = test + 1
              self.queue.put('Test Queue Data #' + str(test))
              running = running - 1
              time.sleep(1)
  
          print 'Updateclient has stopped'
  
  
  if __name__ == "__main__":
      s = Server()
      s.run() 
  
  </code></pre>