Die Python-Netzwerkprogrammierung verwendet Select, um die asynchrone Socket-Vollduplex-Kommunikationsfunktion zu implementieren

Dieser Artikel stellt hauptsächlich die Verwendung von select in der Python-Netzwerkprogrammierung vor, um die Socket-Vollduplex-Kommunikationsfunktion zu realisieren. Er wird hier mit allen geteilt. Freunde in Not können sich darauf beziehen.

Die Beispiele hier Der Artikel beschreibt die Verwendung der Python-Netzwerkprogrammierung. Select implementiert die asynchrone Socket-Vollduplex-Kommunikationsfunktion. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Im vorherigen Artikel „Einfache Verwendung von TCP-Sockets in der Python-Netzwerkprogrammierung“ haben wir die Kommunikation zwischen TCP-Client und -Server implementiert, aber die Funktion ist Das Senden und Empfangen von Nachrichten kann nicht gleichzeitig erfolgen.

Als nächstes werde ich dieses Modul auswählen, um eine Vollduplex-Kommunikation zu erreichen (Informationen können jederzeit empfangen und gesendet werden, natürlich kann es auch mit Multithreading vervollständigt werden, was eine Geschichte später ist).

Also, was ist „Auswählen“?

select – Verwalten Sie in einem Single-Threaded-Netzwerkserverprogramm mehrere Socket-Verbindungen

Der Prototyp von select ist (rlist,wlist,xlist[,timeout ]), Dabei ist rlist das Objekt, das darauf wartet, gelesen zu werden, wlist ist das Objekt, das darauf wartet, geschrieben zu werden, xlist ist das Objekt, das auf eine Ausnahme wartet, und das letzte ist ein optionales Objekt, das die Wartezeit angibt, die Einheit ist s.

select()Der Rückgabewert der Methode ist ein Triplett vorbereiteter Objekte. Wenn innerhalb des Timeout-Zeitraums kein Objekt bereit ist, ist der Rückgabewert eine leere Liste.

Es nutzt Polling, um eine asynchrone Kommunikation zu erreichen.

Im folgenden Programm wird derzeit hauptsächlich die 1-zu-1-Kommunikation unterstützt. Wenn eine Partei die Zeichenfolge „88“ sendet, zeigt dies das Ende der Kommunikation an.

Werfen wir einen Blick auf die spezifische Implementierung:

Zuerst ist der Server.

#!/usr/bin/python
'test TCP server'
from socket import *
from time import ctime
import select
import sys
HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)
tcpSerSock = socket(AF_INET, SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5)
input = [tcpSerSock, sys.stdin]   #input是一个列表，初始有欢迎套接字以及标准输入
while True:
  print 'waiting for connection...'
  tcpCliSock, addr = tcpSerSock.accept()
  print '...connected from:',addr
  input.append(tcpCliSock)  #将服务套接字加入到input列表中
  while True:
    readyInput,readyOutput,readyException = select.select(input,[],[]) #从input中选择，轮流处理client的请求连接（tcpSerSock），client发送来的消息(tcpCliSock)，及服务器端的发送消息(stdin)
    for indata in readyInput:
      if indata==tcpCliSock:  #处理client发送来的消息
        data = tcpCliSock.recv(BUFSIZ)
        print data
        if data=='88':
          input.remove(tcpCliSock)
          break
      else:       #处理服务器端的发送消息
        data = raw_input('>')
        if data=='88':
          tcpCliSock.send('%s' %(data))
          input.remove(tcpCliSock)
          break
        tcpCliSock.send('[%s] %s' %(ctime(), data))
    if data=='88':
      break
  tcpCliSock.close()
tcpSerSock.close()

Das Folgende ist der Clientcode, der sehr ähnlich ist, außer dass er im Vergleich zum Server keine Anforderungsinformationen verarbeiten muss.

#!/usr/bin/python
'test tcp client'
from socket import *
from time import ctime
import select
import sys
HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
input = [tcpCliSock,sys.stdin]
while True:
  readyInput,readyOutput,readyException = select.select(input,[],[])
  for indata in readyInput:
    if indata==tcpCliSock:
      data = tcpCliSock.recv(BUFSIZ)
      print data
      if data=='88':
        break
    else:
      data = raw_input('>')
      if data=='88':
        tcpCliSock.send('%s' %(data))
        break
      tcpCliSock.send('[%s] %s' %(ctime(), data))
  if data=='88':
    break
tcpCliSock.close()

Bisher wurde eine Eins-zu-eins-Vollduplex-Chat-Kommunikation erreicht.

Natürlich müssen wir darüber nachdenken, wie wir eine Many-to-Many-Kommunikation erreichen können?

Wir wissen, dass ein Server mehrere Clients bedienen kann, d über Viele-zu-Viele-Kommunikation?

Wenn A beispielsweise mit B kommunizieren möchte, sendet A die Informationen an den Server und leitet sie dann über den Server an B weiter. Wenn Sie nach dieser Idee schreiben, sollte es möglich sein, eine Viele-zu-Viele-Kommunikation durchzuführen. Wenn Sie interessiert sind, können Sie es versuchen.

Verwandte Empfehlungen:

Einfache Verwendung von TCP-Sockets in der Python-Netzwerkprogrammierung

Das obige ist der detaillierte Inhalt vonDie Python-Netzwerkprogrammierung verwendet Select, um die asynchrone Socket-Vollduplex-Kommunikationsfunktion zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!