Hilo de conexión y PyGTK

Estoy tratando de escribir un progtwig de mensajería instantánea, la interfaz de usuario básica está casi terminada y estoy analizando la parte de recepción de los mensajes. Tengo una clase de interfaz de usuario y una clase Receive_Socket con hilos. Cada vez que el socket de la clase Received_Socket recibe un mensaje, hace un gobject.idle_add () para llamar a un método de UI para mostrar el mensaje en una ventana de chat. Después de la línea gobject.idle.add (), tengo un bucle while que se repite hasta que el mensaje se muestra en realidad en la ventana de chat (quiero que aparezca el mensaje antes de recibir otro mensaje porque leí ese gobject.idle_add () no garantiza el orden de ejecución, y por supuesto quiero que los mensajes se muestren en orden :))

Intenté resumir mi código:

Clase de UI:

Class UI: ##### somewhere in the init ##### self.message_status = 0 def chat_window(self, contact, message=0): Check if a chat window is opened for the contact, if not it opens one. => In reality this check if a gtk.Window containing a gtk.Notebook is opened, => if not it opens one => Then it creates a page for the contact in the notebook, containing a => gtk.Textview which displays messages if message: self.message_display(contact, message) def message_display(self,a,b): => Display the message in the message in the contact's textview self.message_status = 1 

Clase Receive_Socket con hilos:

 Class Receive_Socket(threading.thread): message = sock.recv(1024) => the sender name is written in the message if message: gobject.idle_add(myui.chat_window,sender, message) while not myui.message_status: time.sleep(0.1) myui.message_status = 0 

Código principal:

 if __name__ == "__main__": myui = UI() reception = Receive_Socket() reception.start() gtk.main() 

Mis preguntas :

1) ¿Este tipo de código parece eficiente? ¿Es (tener una clase receptora con hilos junto con mi clase de UI) la mejor manera de proceder?

2) Para cuando se muestre el mensaje, es posible que el zócalo haya recibido 2 o más mensajes, de modo que cuando aparezca nuevamente message = sock.recv (1024), se concatenarán múltiples mensajes en el mensaje variable. Pensé en incluir la longitud del mensaje en cada mensaje, por lo que si hay más de 1 mensaje en los 1024 bytes, tomará el mensaje y pondrá el rest en una variable message_buffer y antes de hacer un sock.recv (1024) nuevamente verificará si la variable message_buffer contiene cualquier cosa y, si es así, coloca el message_buffer en la variable de mensaje en lugar de sock.recv (1024). ¿Hay una solución más fácil / mejor para hacer esto?

Gracias por adelantado,

Nolhian

  1. No. No uses hilos. En su lugar, use glib.io_add_watch para hacer que gtk / glib llame a su función cuando el socket esté listo para leer. De esa manera no congelarás tu GUI y no necesitarás hilos. Tampoco necesitarás idle_add .

  2. Si hace 1 , no tendrá este problema, ya que los mensajes llegarán en orden y no habrá subprocesos concurrentes para confundir los datos.