Gevind, ikke-blokerende websocket klient

Jeg ønsker at køre et program i Python, der sender en besked hver anden via web sockets til en Tornado server. Jeg har brugt som eksempel på websocket-klient;

Dette eksempel ikke arbejde, fordi ws.run_forever() vil stoppe udførelse af while-løkken.

Kan nogen give mig et eksempel på, hvordan man korrekt gennemføre dette som en gevind klasse, som jeg både kan ringe, sende metode, men også modtage beskeder?

import websocket
import thread
import time

def on_message(ws, message):
    print message

def on_error(ws, error):
    print error

def on_close(ws):
    print "### closed ###"

def on_open(ws):
    pass

if __name__ == "__main__":
    websocket.enableTrace(True)
    ws = websocket.WebSocketApp("ws://echo.websocket.org/", on_message = on_message, on_error = on_error, on_close = on_close)
    ws.on_open = on_open
    ws.run_forever()

    while True:
        #do other actions here... collect data etc.
        for i in range(100):
            time.sleep(1)
            ws.send("Hello %d" % i)
        time.sleep(1)

OriginalForfatteren Chris | 2015-03-19

1 svar

  1. 15

    Der er et eksempel i deres github side, der gør netop dette. Det ser ud som du startede ud af dette eksempel og tog den kode, der sender beskeder hver anden ud af on_open og indsættes efter run_forever ringe, at BTW kører, indtil stikket er ikke tilsluttet.

    Måske du har problemer med de grundlæggende begreber her. At der altid vil være en tråd dedikeret til at lytte til stikket (i dette tilfælde den røde tråd, som kommer ind i et loop inde i run_forever venter på beskeder). Hvis du ønsker at have nogle andre ting i gang, du har brug for en anden tråd.

    Nedenfor er en anden version af deres eksempel kode, hvor der i stedet for at bruge den røde tråd, som “socket-lytteren”, en anden tråd er oprettet, og run_forever kører der. Jeg ser det som en smule mere kompliceret, da du er nødt til at skrive kode til at sikre stikket er tilsluttet, mens du kan bruge den on_open tilbagekald, men måske vil det hjælpe dig til at forstå.

    import websocket
    import threading
    from time import sleep
    
    def on_message(ws, message):
        print message
    
    def on_close(ws):
        print "### closed ###"
    
    if __name__ == "__main__":
        websocket.enableTrace(True)
        ws = websocket.WebSocketApp("ws://echo.websocket.org/", on_message = on_message, on_close = on_close)
        wst = threading.Thread(target=ws.run_forever)
        wst.daemon = True
        wst.start()
    
        conn_timeout = 5
        while not ws.sock.connected and conn_timeout:
            sleep(1)
            conn_timeout -= 1
    
        msg_counter = 0
        while ws.sock.connected:
            ws.send('Hello world %d'%msg_counter)
            sleep(1)
            msg_counter += 1
    Hele serveren kører derefter i en tråd? Hvad hvis denne tråd bliver mættet?
    Hvad mener du med “mættet” her?
    Jeg mente, at hvis det var at bruge flere tråde, kan det processen meget mere data per sekund. Med en tråd, føler jeg du ikke bruger hele dit CPU og at tråden kan blive overvældet med data relativt hurtigt.
    gevinddrejning ville øge effektiviteten, hvor der ingen ventetid er involveret; ved slutningen af dagen, GIL sikrer, at din stadig kører en tråd
    python er bestemt ikke flertrådede. hvis du ønsker at håndtere masser af forbindelser, skal du bruge asyncio og multiprocessing at aflevere beskeder til andre processer, der gør arbejdet. når du ønsker at returnere et resultat til kunden, kan du derefter gemme det i et svar kø, der bliver samlet op af de vigtigste asyncio processen og vender tilbage

    OriginalForfatteren Ricardo Gemignani

Skriv et svar

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *