La programmation réseau Python utilise select pour implémenter la fonction de communication asynchrone full-duplex du socket

Cet article présente principalement l'utilisation de select dans la programmation réseau Python pour réaliser la fonction de communication asynchrone full-duplex du socket. Il est partagé avec tout le monde ici. Les amis dans le besoin peuvent s'y référer

Les exemples contenus dans cet article. L'article décrit l'utilisation de la programmation réseau Python. Select implémente la fonction de communication asynchrone full-duplex du socket. Partagez-le avec tout le monde pour votre référence, les détails sont les suivants :

Dans l'article précédent "Utilisation simple du socket TCP dans la programmation réseau Python", nous avons implémenté la communication entre le client TCP et le serveur, mais la fonction est très limité. L’envoi et la réception de messages ne peuvent pas avoir lieu en même temps.

Ensuite, je sélectionnerai ce module pour réaliser une communication full-duplex (les informations peuvent être reçues et envoyées à tout moment, bien sûr, elles peuvent également être complétées par du multi-thread, ce qui sera une histoire plus tard).

Alors, qu'est-ce que la sélection ?

select - Dans un programme serveur réseau monothread, gérez plusieurs connexions socket

Le prototype de select est (rlist,wlist,xlist[,timeout ]), où rlist est l'objet en attente de lecture, wlist est l'objet en attente d'écriture, xlist est l'objet en attente d'exception et le dernier est un objet facultatif, spécifiant le temps d'attente, l'unité est s.

select()La valeur de retour de la méthode est un triplet d'objets préparés. Si aucun objet n'est prêt dans le délai d'attente, la valeur de retour sera une liste vide.

Il utilise le sondage pour réaliser une communication asynchrone.

Dans le programme suivant, il prend actuellement principalement en charge la communication 1-to-1. Lorsque l'une des parties envoie la chaîne « 88 », cela signifie que la communication est terminée.

Jetons un coup d'œil à l'implémentation spécifique :

Le premier est le serveur.

#!/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()

Ce qui suit est le code client, qui est très similaire, sauf qu'il n'a pas besoin de traiter les informations de la demande par rapport au serveur.

#!/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()

Jusqu'à présent, une communication par chat en duplex intégral a été réalisée.

Bien sûr, nous devons réfléchir à la manière de parvenir à une communication plusieurs-à-plusieurs ?

Nous savons qu'un serveur peut servir plusieurs clients, c'est-à-dire que le serveur a une relation un-à-plusieurs avec le client lui-même. Pouvons-nous donc utiliser le serveur comme intermédiaire pour transmettre des informations afin de réaliser quoi. à propos de la communication plusieurs-à-plusieurs ?

Par exemple, si A souhaite communiquer avec B, alors A envoie les informations au serveur, puis les transmet à B via le serveur. Si vous écrivez selon cette idée, il devrait être possible d'effectuer une communication plusieurs-à-plusieurs. Si vous êtes intéressé, vous pouvez l'essayer.

Recommandations associées :

Utilisation simple des sockets TCP dans la programmation réseau Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!