一、粘包优化方案
之前我们解决粘包的方式是用struct模块来制作一个报头，但是这个解决的方案是有漏洞的，当我们需要传送的文件大于2g时将会报错。所以我们今天将用json来制作报头。
from socket import * import subprocess import struct import json ss = socket(AF_INET,SOCK_STREAM) ss.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) ss.bind(('127.0.0.1',8082)) ss.listen(5) print('starting...') while True : #链接循环 conn,addr = ss.accept() #链接，客户的的ip和端口组成的元组 print('-------->',conn,addr) #收，发消息 while True :#通信循环 try : cmd = conn.recv(1024) res = subprocess.Popen(cmd.decode('utf-8'), shell = True, stdout = subprocess.PIPE, stderr = subprocess.PIPE) stdout = res.stdout.read() stderr = res.stderr.read() #制作报头 h_dic = { 'total_size': len(stdout) + len(stderr), 'filename': None, 'md5': None} h_json = json.dumps(h_dic) h_bytes = h_json.encode('utf-8') #发送阶段 #先发报头长度 conn.send(struct.pack('i',len(h_bytes))) #再发报头 conn.send(h_bytes) #最后发送命令的结果 conn.send(stdout) conn.send(stderr) except Exception : break conn.close() ss.close() 服务端
from socket import * import struct import json cs = socket(AF_INET,SOCK_STREAM) #买手机 cs.connect(('127.0.0.1',8082)) #绑定手机卡 #发，收消息 while True : cmd = input('>>: ').strip() if not cmd : continue cs.send(cmd.encode('utf-8')) #先收报头的长度 h_len = struct.unpack('i',cs.recv(4))[0] #再收报头 h_bytes = cs.recv(h_len) h_json = h_bytes.decode('utf-8') h_dic = json.loads(h_json) total_size = h_dic['total_size'] #最后收数据 recv_size = 0 total_data = b'' while recv_size < total_size : recv_data = cs.recv(1024) recv_size += len(recv_data) total_data += recv_data print(total_data.decode('gbk')) cs.close() 客户端
二、知识储备
进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。
对操作系统基础知识比较模糊的可以在阅读本文前预习计算机基础2、操作系统http://www.cnblogs.com/liluning/p/7162317.html
即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在。
#一 操作系统的作用：
1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
2：管理、调度进程，并且将多个进程对硬件的竞争变得有序
#二 多道技术：
1.产生背景：针对单核，实现并发
ps：
现在的主机一般是多核，那么每个核都会利用多道技术，但是核与核之间没有使用多道技术切换这么一说；
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个cpu中的任意一个，具体由操作系统调度算法决定。
2.时间上的复用（复用一个cpu的时间片）+空间上的复用（如内存中同时有多道程序）
三、进程
1、进程概念
进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。正在进行的一个过程或者说一个任务。而负责执行任务则是cpu
2、进程和程序
程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。
需要强调的是：同一个程序执行两次，那也是两个进程，比如打开暴风影音，虽然都是同一个软件，但是一个可以播放苍井井，一个可以播放小泽泽。
3、并发与并行
无论是并行还是并发，在用户看来都是'同时'运行的，不管是进程还是线程，都只是一个任务而已，真实干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务
1） 并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发，（并行也属于并发）
你是一个cpu，你同时谈了三个女朋友，每一个都可以是一个恋爱任务，你被这三个任务共享 要玩出并发恋爱的效果， 应该是你先跟女友1去看电影，看了一会说：不好，我要拉肚子，然后跑去跟第二个女友吃饭，吃了一会说：那啥，我 去趟洗手间，然后跑去跟女友3开了个房
2）同时运行，只有具备多个cpu才能实现并行
单核下，可以利用多道技术，多个核，每个核也都可以利用多道技术（多道技术是针对单核而言的）
有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，
一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术
而一旦任务1的I/O结束了，操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行，由操作系统说了算)，可能被分配给四个cpu中的任意一个去执行
4、同步与异步
同步执行：一个进程在执行某个任务时，另外一个进程必须等待其执行完毕，才能继续执行
异步执行：一个进程在执行某个任务时，另外一个进程无需等待其执行完毕，就可以继续执行，当有消息返回时，系统会通知后者进行处理，这样可以提高执行效率
打电话时就是同步通信，发短息时就是异步通信。
四、python的并发编程
1、multiprocessing模块
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数）
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件
进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
2、Process类的介绍
1）进程的创建
Process(target = talk,args = (conn,addr)) #由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
2）参数介绍
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
3）方法介绍
p.start()：启动进程，并调用该子进程中的p.run() p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁 p.is_alive():如果p仍然运行，返回True p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
4）属性介绍
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 p.name:进程的名称 p.pid：进程的pid p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
3、process类的使用
注意：在windows中Process()必须放到# if __name__ == '__main__':下
1）开启进程的方式一：
from multiprocessing import Process
import time,random
import os
def piao(name):
print(os.getppid(),os.getpid())
print('%s is piaoing' %name)
time.sleep(random.randint(1,3))
print('%s is piao end' %name)
if __name__ == '__main__':
p1=Process(target=piao,kwargs={'name':'alex',})
p2=Process(target=piao,args=('wupeiqi',))
p3=Process(target=piao,kwargs={'name':'yuanhao',})
p1.start()
p2.start()
p3.start()
print('主进程',os.getpid())
#os.getppid(),os.getpid()
#父进程id，当前进程id
2）开启进程的方式二：
from multiprocessing import Process
import time,random
import os
class Piao(Process):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
print(os.getppid(),os.getpid())
print('%s is piaoing' %self.name)
# time.sleep(random.randint(1,3))
print('%s is piao end' %self.name)
if __name__ == '__main__':
p1=Piao('alex')
p2=Piao('wupeiqi')
p3=Piao('yuanhao')
p1.start()
p2.start()
p3.start()
print('主进程',os.getpid(),os.getppid())
4、将基于tcp协议的socket通信变成并发的形式
服务端：
from socket import *
from multiprocessing import Process
s=socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
s.bind(('127.0.0.1',8088))
s.listen(5)
def talk(conn,addr):
while True: #通信循环
try:
data=conn.recv(1024)
if not data:break
conn.send(data.upper())
except Exception:
break
conn.close()
if __name__ == '__main__':
while True:#链接循环
conn,addr=s.accept()
p=Process(target=talk,args=(conn,addr))
p.start()
s.close()
客户端：
from socket import *
c=socket(AF_INET,SOCK_STREAM)
c.connect(('127.0.0.1',8088))
while True:
msg=input('>>: ').strip()
if not msg:continue
c.send(msg.encode('utf-8'))
data=c.recv(1024)
print(data.decode('utf-8'))
c.close()