Para simular o processo de comunicação TCP, este exemplo se conecta várias vezes, usando um método de múltiplos processos. A função realizada é que o multi-cliente se conecta à porta 21567 do servidor, o método de conexão é TCP, envia dados ao servidor, o servidor imprime os dados e, em seguida, envia feedback ([hora atual] envia dados) para cada cliente
importar soquete
importar sistema operacional a
partir do momento
host = ''
porta = 21567
addr = (host, porta)
s = socket.socket ()
s.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind (addr)
s.listen (2)
while True: ## O servidor de controle de loop externo aguarda para receber a conexão do cliente
cli_sock, cli_addr = s.accept ()
pid = os.fork () ## Use a função fork do módulo os para copiar o processo.
if pid: ## Julgamento, se pid não for 0, é igual ao processo principal
cli_sock.close () ## O processo principal é responsável apenas pela conexão do servidor, feche a conexão do cliente
enquanto True: ## Adicione um loop para controlar o processo principal O
resultado da operação do processo zombie result = os.waitpid (-1, 1) [0] ## Aqui, -1 representa o formato da linguagem C, 1 significa que o processo não trava, porque o resultado retornado pelo os.waitpid é um yuan Grupo, o primeiro item da tupla é o pid do processo. Então, pegue a seguinte tabela 0
if result == 0: ## Julgamento, se o processo filho pid for 0, significa que é um processo zumbi (saída), not 0 é uma
interrupção normal do processo filho em execução
: else # # Se pid não for 0, será igual a um filho Processo
s.close () ## O processo filho é responsável por todas as operações do cliente. Mas não é responsável pela operação do servidor, então feche o servidor.
while True: ## O loop interno é responsável por controlar a recepção e a transmissão de
dados do servidor rdata = cli_sock.recv (1024)
rdata = rdata.decode ('utf8')
se rdata.strip () == 'quit':
break
print ( rdata.strip ())
sdata = '[% s]% s'% (strftime ('% H:% S:% M'), rdata)
cli_sock.send (sdata.encode ('utf8'))
cli_sock.close ()
exit () # Aqui é muito importante. Aqui está o trabalho que pertence ao processo filho. Caso contrário, escreva exit. Depois que o processo filho concluir seu trabalho, ele entrará novamente no loop e o processo filho também gerará um processo filho, resultando em uma bomba de forquilha.
s.close ()
Este exemplo é várias conexões, a programação funcional e a execução do programa são executadas de cima para baixo. Relativamente fácil de entender. Em geral, o servidor espera para receber dados, mas quando o cliente se conecta, cria um processo filho. Julgamento, se for o processo principal, feche o serviço de conexão do cliente. Se é um processo filho. Feche o serviço de conexão do servidor. Aguarde o cliente se conectar ao processo principal. Manipule outras tarefas especificamente para o processo filho. Como vários processos podem gerar processos zumbis, o trabalho de lidar com processos zumbis é entregue ao processo principal. Por fim, observe que o processo filho está dentro do loop externo. Se o processo filho não for encerrado após a conclusão do trabalho. Então, quando o ciclo recomeçar, uma bomba de garfo será gerada. Gerando processos filhos continuamente.
