python 并发编程（socketserver）

下面的例子是简单的ssh 登录，其实也就是客户端把指令发送给服务器。服务器把结果返还给客户端，客户端再在终端展现

服务端代码：
#Author:BigBao
#Date:2018/7/18
# 我们之前没有实现并发的原因是，我们之前是链接循环加通信循环，我们只有建立连接后才能通信，通信的过程中腾不出手来建立连接
# 所以现在我们得把链接循环和通信循环给分开，一个class一直在建立连接，一个class一直在通信
# 我们之前的是我们必须创建过链接之后立马去通信，通过过程中部可以去建立连接
'''
socketserver
封装了多进程，多线程
同时还封装了多路复用，把我们的程序性能发挥到机制
'''
import socketserver
import subprocess
import json
import struct
# 通信循环
class MyTcpHandler(socketserver.BaseRequestHandler):   # BaseRequestHandler 专门用来负责处理通信相关信息的
    def handle(self):   # 这里必须定义一个handle方法，而且方法名必须是handle, sockerserver 会自动去调用handle这个方法
        print(self.request) # 这里的self.request  相当于我们之前看到的conn那个对象（  conn,client_addr=server.accept()   ）
        while True:
            try:
                recv_cliend_cmd = self.request.recv(1024)  #接收客户端的指令
                if not recv_cliend_cmd:break
                # 下面就要对客户端发送的指令进行处理了
                obj=subprocess.Popen(recv_cliend_cmd.decode('utf-8'),shell=True,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE)
                stdout = obj.stdout.read()
                stderr = obj.stderr.read()
                # 下面开始创建报头(随意写的)，这里我们真正用到的就是字典里的total_size
                header_dic={
                    'total_size':len(stdout)+len(stderr),
                    'filename':'xxx.mp4',
                    'md5sum':'8f6fbf8347faa4924a76856701edb0f3'
                }
                header_json = json.dumps(header_dic)
                header_bytes = header_json.encode('utf-8')
                self.request.send(struct.pack('i',len(header_bytes)))   # 这个发送过去为固定的字节数 4 个，所以客户端第一次接收四个字节即可

                self.request.send(header_bytes)

                self.request.send(stdout)
                self.request.send(stderr)

            except ConnectionResetError:break
        self.request.close()

# 连接循环
if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyTcpHandler)   #基于Tcp的多线程服务端
    server.serve_forever()
# 客户端发来请求，就建立一个连接，server 立马造一个线程，然后再把MyTcpHandler 类实例化得到一个对象，触发对象下面的handle方法,把连接丢给 handle 方法（handle方法下的self.request 就是建立的连接）
# 也就是说客户端来一个连接，建立后就会触发通信循环的的handle 方法，我们可以看一下self.request 打印出来的东西就是本地IP：端口   客户端IP:端口

客户端代码

#Author:BigBao
#Date:2018/7/18
import socket
import struct
import json
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect(('127.0.0.1',8080))
while True:
    cmd = input('please input your cmd: ').strip()
    if not cmd:continue
    client.send(cmd.encode('utf-8'))
    obj = client.recv(4)
    header_size = struct.unpack('i',obj)[0]
    header_bytes = client.recv(header_size)
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)
    total_size = header_dic['total_size']
    recv_size = 0
    res = b''
    while recv_size < total_size:
        recv_data = client.recv(1024)
        res+=recv_data
        recv_size+= len(recv_data)
    print(res.decode('gbk'))
client.close()

我们上面处理的黏包问题是发生在服务端发数据给客户端，客户端的数据接收不完全的解决方案。要是涉及到两边都有黏包问题的话，解决方案也是上面一样解决