网络编程问题

Question

我写了一个客户端服务器程序，其中服务器向客户端发送程序，客户端执行接收到的程序。在本例中，它是 OpenGL 中的线条绘制程序。问题是，在运行服务器和客户端时，整个程序（即，将程序发送到服务器和客户端）有时会执行，但有时不会执行。客户端连接后就卡住了。该程序也不会停止。在我朋友的系统中同样有效，但在我的系统中它仅有时有效（大多数时候它不会）。可能是什么原因？我错过了什么吗？

我的服务器代码：

from OpenGL.GLUT import *
from OpenGL.GLU import *
from OpenGL.GL import *
import sys
import threading
import os
import socket

class ClientThread ( threading.Thread ):
 # Override Thread's __init__ method to accept the parameters needed:
 def __init__ ( self, channel, details ):
  self.channel = channel
  self.details = details
  threading.Thread.__init__ ( self )

 #Codes to be executed when thread is executed:
 def run ( self ):
  a1=self.channel.recv(1024)
  print "client says:"+a1
  print 'Received connection:', self.details [ 0 ]
  finp = open("stringcheck.py","r")
  #self.channel.send("#start\n")
  info = finp.readlines() 
  for record in info:
   self.channel.send(record)
  #self.channel.send(info)
  self.channel.send("#p") 


server = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
server.bind ( ( '127.0.0.1', 4500) )
#Listens for connections made to socket.
#Specifies maximum number of queued connection.
server.listen ( 5 )
while True:
 channel, details = server.accept()
 #Create an instance of thread class and call its start method.
 ClientThread ( channel, details ).start()

我的客户端代码：

from OpenGL.GLUT import *
from OpenGL.GLU import *
from OpenGL.GL import *
OpenGL.ERROR_CHECKING=False
import os
import socket
import threading
import thread
import subprocess

class ConnectionThread( threading.Thread ):

 def run ( self ):

  client = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
  client.connect( ( '127.0.0.1', 9000) )
  client.send("connected")
  a=client.recv(1024)
  b=a
  f=1 
  while f:
   print 'sdf'
   a = client.recv(1024)
   print 'qwe'
   if a=="#p":
    f=0
    break
   b+=a
  print b
  exec(b)

  client.close()
ConnectionThread().start()
 from OpenGL.GLUT import *
from OpenGL.GLU import *
from OpenGL.GL import *
OpenGL.ERROR_CHECKING=False
import os
import socket
import threading
import thread
import subprocess

class ConnectionThread( threading.Thread ):

 def run ( self ):

  client = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
  client.connect( ( '127.0.0.1', 9000) )
  client.send("connected")
  a=client.recv(1024)
  b=a
  f=1 
  while f:

   a = client.recv(1024)
   print 'qwe'
   if a=="#p":
    f=0
    break
   b+=a
  print b
  exec(b)

  client.close()
ConnectionThread().start()

Answer 1

1. TCP 套接字是一个流 （数据包是实现细节）

网络堆栈经过优化以限制发送的数据包数量。因此，当您在套接字上多次调用 send() 时，网络堆栈可以自由地拆分（或不拆分）多个数据包之间的数据。

在运行于真实网络上的计算机上，这比环回连接慢得多，如果在调用 send() 时仍有数据包等待发送，则新数据为附加到等待数据包。在接收端，网络堆栈可以自由合并多个数据包（从套接字接收的数据被缓冲）以立即向您呈现数据。

因此，在服务器中，您可以编写：

for record in info:
    self.channel.send(record)
self.channel.send("#p") 

最后一个数据包可能包含程序的结尾和终止符，它们连接在一起。
在客户端中：

a = client.recv(1024)
if a=="#p":
    break

终止符可能不在接收到的数据包的开头，也可能不是数据包中存在的唯一字符。如果是这种情况，那么您不会检测到终止符，不会退出循环，再次调用 recv() ，并在此停止，因为 recv() 是一个阻塞调用，服务器将不再发送任何数据。

因此，您必须选择另一种方式来了解服务器何时完成发送数据。有很多可能性：

• 第一个明显的方法是在客户端，而不是 if a=="#p":，编写 if a.endswith("#p"):代码>.这可以纠正代码中存在的问题，
• 您也可以选择先发送程序的长度，然后再发送。客户端读取长度，然后读取该数量的字符并停止
• 服务器可以在发送程序完成后简单地关闭连接。在客户端中，当 recv() 返回空字符串时，您检测到连接已关闭，然后您就知道程序已收到。不幸的是，如果服务器在发送整个程序之前崩溃，您将在客户端上执行不完整的程序，

还有无数其他可能性来纠正此问题...

2。你的接收逻辑是错误的

现在，仔细看看接收逻辑（编辑代码以删除不相关的行）：

1. a=client.recv(1024)
2. b=a
3. f=1 
4. while f:
5.     a = client.recv(1024)
6.     if a=="#p":
7.         f=0
8.         break
9.     b+=a

在这里，你首先等待一些数据（第1行）。然后输入 while 循环（第 4 行），并再次等待一些数据（第 5 行）！

recv() 是一个阻塞调用：这意味着它不会返回，直到有一些数据要返回或连接关闭。如果服务器发送的字节数少于 1024 个字节（包括终止符），您将收到第 1 行的所有内容（包括终止符），但仍需等待第 5 行的更多数据...

请注意，您的测试中仍然存在一个错误：如果分隔符被分割为 2 个 recv() 调用（如果程序长度恰好为 1023 字节，则会发生这种情况），a.endswith('#p') 永远不会计算为 正确。

所以这里是一个正确的接收逻辑，它在收到一些数据后立即测试终止符：

a = client.recv(1024)    
b = a
f = 1 
while f:
    if b.endswith("#p"):
        f=0
        break
    a = client.recv(1024)
    b += a

请注意，通过删除不必要的变量可以大大简化这一点：

b = client.recv(1024)
while not b.endswith("#p"):
    b += client.recv(1024)

3。正确释放代码中使用的资源

我一开始并没有强调这一点，但你应该始终正确关闭你的连接！

python 语言是这样设计的，一旦保存连接的变量不再被引用（在您的情况下，当它超出范围时），连接就会隐式关闭。但是，显式关闭它会明确您期望连接在哪个点关闭。

某些实现可能会决定推迟资源的释放（Jython 用户可能遇到过这个问题），使连接保持打开状态...这没问题，但是当您的程序增长到产品功能更加齐全。