30、进程的基础理论，并发（multiprocessing模块）

时间 2019-11-20

标签进程基础理论并发 multiprocessing 模块繁體版

原文原文链接

咱们以前基于tcp所作的通讯都只能一个一个连接只有关闭当前连接时才能去连接下一个通讯，这显然与现实状况不合。今天咱们未来学一个新的概念进程，来作一个python多进程的并发编程。还会贴一个用json序列化将上个随笔中的ssh例子优化的代码。html

本篇导航：python

1、粘包优化方案算法

以前咱们解决粘包的方式是用struct模块来制做一个报头，可是这个解决的方案是有漏洞的，当咱们须要传送的文件大于2g时将会报错。因此咱们今天将用json来制做报头。shell

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、知识储备编程

进程的概念起源于操做系统，是操做系统最核心的概念，也是操做系统提供的最古老也是最重要的抽象概念之一。操做系统的其余全部内容都是围绕进程的概念展开的。json

对操做系统基础知识比较模糊的能够在阅读本文前预习计算机基础二、操做系统http://www.cnblogs.com/liluning/p/7162317.htmlwindows

即便能够利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在。安全

#一 操做系统的做用：
    1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
    2：管理、调度进程，而且将多个进程对硬件的竞争变得有序

#二 多道技术：
    1.产生背景：针对单核，实现并发
    ps：
    如今的主机通常是多核，那么每一个核都会利用多道技术，可是核与核之间没有使用多道技术切换这么一说；
    有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再从新调度，会被调度到4个cpu中的任意一个，具体由操做系统调度算法决定。
    
    2.时间上的复用（复用一个cpu的时间片）+空间上的复用（如内存中同时有多道程序）

3、进程网络

一、进程概念并发

进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。正在进行的一个过程或者说一个任务。而负责执行任务则是cpu

二、进程和程序

程序仅仅只是一堆代码而已，而进程指的是程序的运行过程。

须要强调的是：同一个程序执行两次，那也是两个进程，好比打开暴风影音，虽然都是同一个软件，可是一个能够播放苍井井，一个能够播放小泽泽。

三、并发与并行

不管是并行仍是并发，在用户看来都是'同时'运行的，不论是进程仍是线程，都只是一个任务而已，真实干活的是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的并发编程

一、multiprocessing模块

multiprocessing模块用来开启子进程，并在子进程中执行咱们定制的任务（好比函数）

multiprocessing模块的功能众多：支持子进程、通讯和共享数据、执行不一样形式的同步，提供了Process、Queue、Pipe、Lock等组件

进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。

二、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字符的字符串。这个键的用途是为涉及网络链接的底层进程间通讯提供安全性，这类链接只有在具备相同的身份验证键时才能成功（了解便可）

三、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())

四、将基于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()