进程：multiprocessing

multiprocessing：

multiprocessing模块允许程序员在给定机器上充分利用多个处理器。它可以在Unix和Windows上运行。

 在中multiprocessing，通过创建Process 对象然后调用其start()方法来生成进程。 Process 遵循的API threading.Thread。多进程程序的一个简单示例：

class Process(object):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self.name = ''
        self.daemon = False
        self.authkey = None
        self.exitcode = None
        self.ident = 0
        self.pid = 0
        self.sentinel = None

    def run(self):
        pass

    def start(self):
        pass

    def terminate(self):
        pass

    def join(self, timeout=None):
        pass

    def is_alive(self):
        return False

from multiprocessing import Process
import time,os

def func(arg1,arg2): #子进程
    print(arg1+'\t'+arg2)
    time.sleep(5)
    print('编号1：我是func，我的进程号:%s'%os.getpid())
    print('编号2：我是func，我的父进程号：%s'%os.getppid())


if __name__ == '__main__':
    arg1 = 'aike'
    arg2 = 'cool'
    p = Process(target=func,args=(arg1,arg2)) #创建一个Process对象
    p.start()   #启动子进程
    time.sleep(3)
    print(p.pid)  # 子进程进程号
    print('编号3：start后，子进程未结束，依然乡下执行')
    print('编号4：我是func的父进程，我的进程号:%s\t我的父进程号：%s'%(os.getpid(),os.getppid()))

结论：

os,getpid 获取当前进程的进程号
os.getppid 获取当前进程的父进程号
Process.pid 可以获取这个对象的进程号
Process.name 获取这个进程对象的名字
Process可以创建一个进程对象，target指定一个函数的内存地址，该函数去实现子进程的操作，args为需要传的参数（元祖类型）
当主进程开启了子进程：
    主进程自己的代码如果执行时间长,等待自己的代码执行结束
    子进程的执行时间长,主进程会在主进程代码执行完毕之后等待子进程执行完毕之后 主进程才结束
Process当中的几个方法：
　　run：创建一个类去创建Process对象时，这个类必须继承process，切必须实现run方法，run方法中是子进程中执行的代码
　　is_alive：检验一个进程是否活着的状态，当一个子进程结束，马上进行检验，因为操作系统反应需要时间，在这段时间进行检验，可能会返回True
　　start:启动子进程
　　join：感知一个子进程的结束,将异步的程序改为同步。只有当子进程执行结束时，主进程才继续向下执行
　　terminate：结束子进程
Process当中的几个重要属性：
　　name：查看进程名字
　　daemon：设置是否为守护进程
　　pid：查看进程号

from multiprocessing import Process
import time
def func(args):
    time.sleep(2)
    print(args)
    print('子进程执行完毕')

if __name__ == '__main__':
    p = Process(target=func,args=('aike',))
    p.start()#启动子进程
    print('我是主进程，我开始等待子进程执行完毕')
    p.join()#感知一个子进程的结束,将异步的程序改为同步。只有当子进程执行结束时，主进程才继续向下执行
    p.terminate()#结束子进程
    time.sleep(2)
    print(p.is_alive())#检验一个进程是否活着的状态,当一个子进程结束，马上进行检验，因为操作系统反应需要时间，在这段时间检验，可能会返回True
    print('我是主进程，子进程执行结束')

创建多个子进程：
　　第一种方法：直接Process创建

from multiprocessing import Process
import time
def func(args):
    print('%s正在上传'%args)
    time.sleep(1)
    print('%s上传完毕'%args)


if __name__ == '__main__':
    lis_p = []
    for i in range(10):#创建十个子进程
        p = Process(target=func,args=('aike%s'%i,))
        lis_p.append(p)
        p.start()
    [p.join() for p in lis_p]#等待十个子进程结束操作后，主进程才进行下步操作，使用场景为写文件等
    print('所有对象上传完毕,你可以进行访问了')

　　第二种方法：通过类继承创建

from multiprocessing import Process
import time
class MyProcess(Process): #必须继承Process
    def __init__(self,args):
        super().__init__()#需要传参时，自定义__init__方法，用super继承父类的默认参数
        self.args = args

    def run(self):#子进程的实现
        time.sleep(1)
        print('我是%s'%self.args)


if __name__ == '__main__':
    p = MyProcess(1)
    p.start()
    p2 = MyProcess(2)
    print('不需要等p结束，主进程继续异步执行')
    p2.start()

多进程之间的数据隔离：主进程与子进程的数据不互通

from multiprocessing import Process
def func():
    global i
    i = 0
    print(i)

if __name__ == '__main__':
    i = 10
    p = Process(target=func)
    p.start()
    print('主进程',i)

#打印：
主进程 10
0

守护进程：

　　当这个子进程设置为守护进程，它会随着主进程的代码执行结束而结束

from  multiprocessing import Process
import time
def func():
    # while True:
        time.sleep(5)
        print('我是func')

def func2():
    while True:
        time.sleep(1)
        print('我是守护进程，我还活着')

if __name__ == '__main__':
    t1 = Process(target=func)
    t2 = Process(target=func2)
    t2.daemon = True #设置为守护进程
    t1.start()
    t2.start()
    t1.join()
    print('我是主进程') 

进程同步控制：
　　进程锁：multiprocessing.Lock
lock = multiprocessing.Lock() 创建一个锁
lock.acquire() 获取锁
lock.release() 释放锁
谁先抢到锁谁先执行，等到该进程执行完成后，其它进程再抢锁执行

#模拟抢票，如果不设置锁，由于程序执行过快，本只有一张余票，但会被多个人抢到
#设置锁后，只有等释放锁，其他人才能拿着锁继续执行下去，类似socket客户端建立监听的listen，只有等一个人结束后，后面人才能进去
from multiprocessing import Process
from multiprocessing import Lock
import time
import json

def ticket(args,lock):
    lock.acquire()
    with open('ticket') as f:
        data_ticket = json.load(f)
        if data_ticket['ticket'] > 0:
            print('%s抢票成功'%args)
            data_ticket['ticket'] -= 1
        else:
            print('%s没有多余的票'%args)
    time.sleep(0.5)
    with open('ticket','w') as f:
        json.dump(data_ticket,f)
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(10):
        p = Process(target=ticket,args=('aike%s'%i,lock))
        p.start()

　　信号量：multiprocessing.Semaphore

　　　　　　　　特点：某一段代码，同一时间，只能被n个进程执行，与进程锁lock类似，进程锁仅能有一个，而信号量能同时多个，一个进程结束后，另外一个进程会补上，直到所有进程都被执行。

#一个洗手间只有2个位置（ Semaphore(2)），restroom代表洗手间，最多同时被2个进程执行
from multiprocessing import Semaphore
from multiprocessing import Process
import time,random
def restroom(args,s):
    s.acquire()
    print('%s进来了'%args)
    time.sleep(random.randint(10,30))
    print('%s出去了'%args)
    s.release()

if __name__ == '__main__':
    s = Semaphore(2)
    for i in range(5):
        p = Process(target=restroom,args=('aike%s'%i,s))
        p.start()

 

　　事件：multiprocessing.Event
　　　　特点：通过一个信号来控制多个进程，同时执行（异步）或者阻塞（同步）

class Event(object):
    def is_set(self):  #查看事件的状态，返回True或Flase
        return False

    def set(self): #修改事件的状态为True
        pass

    def clear(self): #设置事件的状态为Flase
        pass

    def wait(self, timeout=None): #依据事件的状态来决定自己是否在wait处阻塞
        pass

from multiprocessing import Process
from multiprocessing import Event
import time
import random

def light(traffic_light):
    '''
    事件创建出来默认为Flase，当他为Flase状态，改变为True状态，则为绿灯，放行5秒
                            当他为True状态，改变为Flase状态，则为红灯，等待5秒
    '''
    while True:
        if traffic_light.is_set():
            print('红红红红红红红红红红红红')
            traffic_light.clear() #事件状态变为Flase
            # print(traffic_light.is_set())
        else:
            print('绿绿绿绿绿绿绿绿绿绿绿绿绿')
            traffic_light.set() #事件状态变为True
        # print(traffic_light.is_set())
        time.sleep(5)

def cars(car,traffic_light):
    '''
    检测到事件为True状态，即为绿灯，车辆通行
                Flase状态，即为红灯，车辆等待，程序阻塞，等待事件为True状态，即为绿灯后再通行
    '''

    if traffic_light.is_set():
        print('%s过去了'%car)
    else:
        print('%s在等待' % car)
        traffic_light.wait()
        print('%s过去了'%car)


if __name__ == '__main__':
    traffic_light= Event()
    traffic = Process(target=light,args=(traffic_light,)) #创建一个红绿灯进程
    traffic.start()
    for i in range(20):
        car = Process(target=cars,args=('%s号车'%i,traffic_light)) #创建多个车辆进程
        car.start()
        time.sleep(random.random())

 

队列：multiprocessing.Queue

　　创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。 

Queue([maxsize]) 
创建共享的进程队列。
参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。
底层队列使用管道和锁定实现。

class Queue(object):
    def __init__(self, maxsize=-1): #maxsize队列中允许的最大项数。如果省略此参数，则无大小限制。
        self._maxsize = maxsize

    def qsize(self): #返回队列中目前项目的正确数量。
        return 0

    def empty(self): #队列是否为空，空返回True
        return False

    def full(self): #队列是否满，满了返回True
        return False

    def put(self, obj, block=True, timeout=None):   #添加obj对象至队列
        pass

    def put_nowait(self, obj): #
        pass

    def get(self, block=True, timeout=None): #返回elf中的一个项目
        pass

    def get_nowait(self):
        pass

    def close(self): #关闭队列，防止队列中加入更多数据。
        pass

    def join_thread(self): #连接队列的后台线程。
        pass

    def cancel_join_thread(self): #不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。
        pass

Queue([maxsize]) 
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。另外，还需要运行支持线程以便队列中的数据传输到底层管道中。 
Queue的实例q具有以下方法：

q.get( [ block [ ,timeout ] ] ) 
返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。

q.get_nowait( ) 
同q.get(False)方法。

q.put(item [, block [,timeout ] ] ) 
将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。

q.qsize() 
返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。


q.empty() 
如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。

q.full() 
如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。。

q.close() 
关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。

q.cancel_join_thread() 
不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。

q.join_thread() 
连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。



摘自：老男孩女神Eva_j

q = Queue(3)  # 最大存3个对象
q.put('aike')
q.put('chenfan')
q.put('xiaxiang')
print(q.full())  # 队列是否满
print(q.empty())  # 队列是否空
# q.put('dingchao')  # 当队列已经满了再继续添加，程序默认会阻塞，直至有数据被取出
# q.put('aike',block=False)#可以设置为不阻塞，即block = False，但是队列满了会报错
try:
    q.put_nowait(3) # 可以使用put_nowait，如果队列满了不会阻塞，与q.put(block=False)一样，会因为队列满了而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去，但是会丢掉这个消息。
    print('队列已经满了')

q = Queue(3)  # 最大存3个对象
q.put('aike')
q.put('chenfan')
q.put('xiaxiang')
q.get()
q.get()
q.get()
# q.get() #当队列的值已经全部被取出后继续取值，程序默认会阻塞，直至有新的值进入
# q.get(block = False) #可以设置为不阻塞，即block = False，但是没取到值会报错
try:
    q.get_nowait(3) # 可以使用get_nowait，如果队列满了不会阻塞，与q.get(block = False)一样，会因为没取到值而报错。
except: # 因此我们可以用一个try语句来处理这个错误。这样程序不会一直阻塞下去。
    print('队列已经空了')

from multiprocessing import Process
from multiprocessing import Queue

def func1(q):
    q.put('aike')
    q.put('chenfan')
    q.put('xiaxiang')


def func2(q):
    print(q.get()) #aike
    print(q.get())#chenfan


if __name__ == '__main__':
    q = Queue(3) #最大存3个对象
    p1 = Process(target=func1,args=(q,))
    p1.start()
    p2 = Process(target=func2,args=(q,))
    p2.start()

 

　　生产者消费者模型：

　　　　在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

　　为什么要使用生产者和消费者模型：

　　　　在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

　　什么是生产者消费者模型：

　　　　　　生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

from multiprocessing import Queue
from multiprocessing import Process
import time

def producer(name,food,q):
    for i in range(20):
        # time.sleep(1)
        q.put((food+str(i)))
        print('%s生产了%s%s' % (name, i, food))


def consumer(name,q):
    while True:
        time.sleep(0.2)
        food = q.get()
        if food == None:
            print('没有了')
            break
        print('%s买下了%s'%(name,food))


if __name__ == '__main__':
    q = Queue(20)
    p = Process(target=producer,args=('金早绿点','包子',q))
    p.start()
    c = Process(target=consumer,args=('aike',q))
    c.start()
    p.join()
    q.put(None)

 

基于队列实现的生产者与消费者模型的升级版：multiprocessing.JoinableQueue

　　创建可连接的共享进程队列。这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：

q.task_done() 
使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。

q.join() 
生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。 
下面的例子说明如何建立永远运行的进程，使用和处理队列上的项目。生产者将项目放入队列，并等待它们被处理。

from multiprocessing import JoinableQueue
from multiprocessing import Process
import time

def producer(name,food,q):
    for i in range(25):
        # time.sleep(1)
        q.put((food+str(i)))
        print('%s生产了%s%s' % (name, i, food))
    q.join() #阻塞，直到队列中所有项目均被处理


def consumer(name,q):
    while True:
        time.sleep(0.1)
        food = q.get()
        print('%s买下了%s'%(name,food))
        q.task_done() #每次get后需要调用task_done，直到队列所有数据都task_done，join才取消阻塞，如果不调用，join会认为项目没被处理，join会一直阻塞


if __name__ == '__main__':
    q = JoinableQueue(20)#最多存放20个对象
    p = Process(target=producer,args=('金早绿点','包子',q))
    p.start()
    c = Process(target=consumer,args=('aike',q))
    c.daemon = True #设置为守护进程，随着主进程的代码结束而结束
    c.start()
    p.join() #阻塞，直到生产者结束
    print('代码结束，守护进程结束')

 

 管道：multiprocessing.Pipe

#创建管道的类：
Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道
#参数介绍：
dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。
#主要方法：
    conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
    conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象
 #其他方法：
conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法
conn1.fileno():返回连接使用的整数文件描述符
conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。
 
conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    
 
conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

from multiprocessing import Pipe,Process

def func2(conn,conn2):
    conn.close()
    while True:
        try:
            ret = conn2.recv()
            print(ret)
        except EOFError:  #当所有的管口都被关闭，且继续取值，会抛出异常
            print('没有值了')
            conn2.close()
            break
if __name__ == '__main__':
    conn,conn2 = Pipe()
    p2 = Process(target=func2,args=(conn,conn2))
    p2.start()
    conn2.close()
    conn.send('aike')
    conn.close()

 　　注意：管道口的管理问题

管道口的正确管理问题。如果是生产者或消费者中都没有使用管道的某个端点，就应将它关闭。
这也说明了为何在生产者中关闭了管道的输出端，在消费者中关闭管道的输入端。
如果忘记执行这些步骤，程序可能在消费者中的recv（）操作上挂起。
管道是由操作系统进行引用计数的，必须在所有进程中关闭管道后才能生成EOFError异常。
因此，在生产者中关闭管道不会有任何效果，除非消费者也关闭了相同的管道端点。 

from multiprocessing import Pipe,Process,Lock
import time
def producer(food,conn,conn2):
    conn2.close()
    for i in range(50):
        print('生产了%s%s' % (food, i))
        conn.send('%s%s'%(food,i))
    conn.close()


def consumer(name,conn,conn2):
    conn.close()
    while True:
        time.sleep(0.5)
        try:
            ret = conn2.recv()
            print('%s消费了%s'%(name,ret))
        except EOFError:
            print('没有包子了')
            conn2.close()
            break

if __name__ == '__main__':
    conn,conn2 = Pipe()
    pro = Process(target=producer,args=('包子',conn,conn2))#生产者
    pro.start()
    sumer_lis = []
    for i in range(5):
        sumer = Process(target=consumer, args=('aike%s'%i, conn, conn2,))  # 消费者
        sumer_lis.append(sumer)
        sumer.start()
    # sumer = Process(target=consumer,args=('aike',conn,conn2))#消费者
    # sumer.start()
    # sumer1 = Process(target=consumer,args=('chenfan',conn,conn2))#消费者
    # sumer1.start()
    conn.close()
    conn2.close()

管道存在的数据安全问题： 数据访问请求太快，未被系统反应过来，同一数据被多个进程请求访问。解决办法是加锁，但加上锁后，数据虽是轮流访问，但是管道内的所有数据被访问完后，程序会被阻塞。

from multiprocessing import Pipe,Process,Lock
import time
def producer(food,conn,conn2):
    conn2.close()
    for i in range(50):
        print('生产了%s%s' % (food, i))
        conn.send('%s%s'%(food,i))
    conn.send(None)#用于退出消费者循环，否则程序一直阻塞
    conn.send(None)
    conn.send(None)
    conn.send(None)
    conn.send(None)
    conn.close()


def consumer(name,conn,conn2,lock):
    conn.close()
    while True:
        time.sleep(0.5)
        try:
            lock.acquire()
            ret = conn2.recv()
            lock.release()
            if ret:
                print('%s消费了%s'%(name,ret))
            else:
                conn2.close()
                break
        except EOFError:
            print('没有包子了')
            conn2.close()
            break

if __name__ == '__main__':
    lock = Lock()
    conn,conn2 = Pipe()
    pro = Process(target=producer,args=('包子',conn,conn2))#生产者
    pro.start()
    sumer_lis = []
    for i in range(5):
        sumer = Process(target=consumer, args=('aike%s'%i, conn, conn2,lock))  # 消费者
        sumer_lis.append(sumer)
        sumer.start()
    # sumer = Process(target=consumer,args=('aike',conn,conn2))#消费者
    # sumer.start()
    # sumer1 = Process(target=consumer,args=('chenfan',conn,conn2))#消费者
    # sumer1.start()
    conn.close()
    conn2.close()

数据共享：multiprocessing.Manager

进程间数据是独立的，可以借助于队列或管道实现通信，二者都是基于消息传递的
虽然进程间数据独立，但可以通过Manager实现数据共享，事实上Manager的功能远不止于此

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array.

 

from multiprocessing import Manager,Process,Lock
def func(dic,lock):
    lock.acquire()
    dic['int'] -= 1
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    m = Manager()
    dic = m.dict({'int':100}) 
    p_lis = []
    for i in range(20):
        p = Process(target=func,args=(dic,lock))
        p_lis.append(p)
        p.start()
    for p in p_lis:p.join()
    print(dic)

　　注意：

展望未来，基于消息传递的并发编程是大势所趋

即便是使用线程，推荐做法也是将程序设计为大量独立的线程集合，通过消息队列交换数据。

这样极大地减少了对使用锁定和其他同步手段的需求，还可以扩展到分布式系统中。

但进程间应该尽量避免通信，即便需要通信，也应该选择进程安全的工具来避免加锁带来的问题。

以后我们会尝试使用数据库来解决现在进程之间的数据共享问题。

　　一个陷阱：当共享数据类型数一个字典嵌套列表，或者列表嵌套字典等，在子进程修改数据时直接通过下标修改是无效的

from multiprocessing import Manager,Process,Lock
def func(lis):
    lis[0]['int'] -= 1

if __name__ == '__main__':
    m = Manager()
    lis = m.list([{'int':100},50]) #列表嵌套字典
    p_lis = []
    for i in range(20):
        p = Process(target=func,args=(lis,))
        p_lis.append(p)
        p.start()
    for p in p_lis:p.join()
    print(lis)

#打印：
[{'int': 100}, 50]

解决办法： 触发__setitem__方法

from multiprocessing import Manager,Process,Lock
def func(lis):
    '''
    触发__setitem__方法
    '''
    num = lis[0] #{'int': 100}
    num['int'] -= 1 #99
    lis[0] = num #{'int': 100} = {'int': 99}

if __name__ == '__main__':
    m = Manager()
    lis = m.list([{'int':100},50]) #列表嵌套字典
    p_lis = []
    for i in range(20):
        p = Process(target=func,args=(lis,))
        p_lis.append(p)
        p.start()
    for p in p_lis:p.join()
    print(lis)

原因：

　　以上代码中让人困惑的操作的目的是绕过Manager的一个隐秘问题，这个问题是指：Manager对象无法监测到它引用的可变对象值的修改，需要通过触发__setitem__方法来让它获得通知
　　代码中lis[0] = num这行代码就是用来故意触发proxy对象的__setitem__方法的，关于这个问题Python官方文档解释如下：

If standard (non-proxy) list or dict objects are contained in a referent, 
modifications to those mutable values will not be propagated through the manager because the proxy has no way of knowing when the values contained within are modified. 
However, storing a value in a container proxy (which triggers a__setitem__on the proxy object) does propagate through the manager and so to effectively modify such an item,
 one could re-assign the modified value to the container proxy.

 

进程池和multiprocess.Pool模块：

　　为什么要有进程池，进程池的概念：

在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。那么我们要怎么做呢？

在这里，要给大家介绍一个进程池的概念，定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。如果有很多任务需要执行，池中的进程数量不够，任务就要等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。

　　multiprocess.Pool模块：

1 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
2 initializer：是每个工作进程启动时要执行的可调用对象，默认为None
3 initargs：是要传给initializer的参数组

1 p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
2 '''需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()'''
3 
4 p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
5 '''此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。'''
6    
7 p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
8 
9 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

1 方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
2 obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
3 obj.ready():如果调用完成，返回True
4 obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
5 obj.wait([timeout]):等待结果变为可用。
6 obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

代码实例：

from multiprocessing import Pool,Process
import time
def func(args):
    # time.sleep(1)
    args += 1
    return args #进程池拥有返回值

def func2(args):
    args += 1

if __name__ == '__main__':
    #创建一个进程池
    pool = Pool(5)
    start = time.time()
    p = pool.map(func,range(10))
    print(time.time() - start)#0.3028266429901123
    # print(p)

    # 创建多个进程
    p_lis = []
    for i in range(10):
        start = time.time()
        p = Process(target=func2,args=(i,))
        p_lis.append(p)
        p.start()
    for p in p_lis:p.join()
    print(time.time() - start)#0.8240413665771484

apply方法的同步和异步：
　　同步：apply

from multiprocessing import Pool,Process
import time,os
def func(args):
    print('进程号：%s'%os.getpid())
    args += 1
    time.sleep(2)
    return args

if __name__ == '__main__':
    pool = Pool(5) #创建1个进程池，进程池有5个进程
    lis = []
    for i in range(10):
        p = pool.apply(func,args=(i,))# 同步调用，直到本次任务执行完毕拿到返回值p，等待任务func执行的过程中可能有阻塞也可能没有阻塞，
                                        # 但不管该任务是否存在阻塞，同步调用都会在原地等着
        lis.append(p)
    print(lis)
    pool.close()
    pool.join()
    print('进程池任务为空，关闭进程池')

　　　异步：apply_async

from multiprocessing import Pool,Process
import time,os
def func(args):
    print('进程号：%s' % os.getpid())
    args += 1
    time.sleep(1)
    return args

if __name__ == '__main__':
    pool = Pool(5)
    # lis = []
    for i in range(10):
        p = pool.apply_async(func,args=(i,))# 异步运行，根据进程池中有的进程数，每次最多5个子进程在异步执行
                                          # 返回结果之后，将结果放入列表，归还进程，之后再执行新的任务
                                          # 需要注意的是，进程池中的三个进程不会同时开启或者同时结束
                                          # 而是执行完一个就释放一个进程，这个进程就去接收新的任务。
        # 异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果
        # 否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
        # lis.append(p.get()) #get自带阻塞,等收到返回值才会进行下个进程任务，#
                                # 使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get
    # print(lis)
    pool.close()
    pool.join()
    print('进程池任务为空，关闭进程池')

 进程池版本socket并发：

import socket,os
from multiprocessing import Pool,Process

def chat(conn):
    while True:
        ret = conn.recv(1024).decode('utf-8')
        print('进程号%s发送消息:'%os.getpid(),ret)
        # info = input('请输入消息:').encode('utf-8')#子进程当中的IO操作，不会在pycharm当中反映。
        conn.send('收到'.encode('utf-8'))

if __name__ == '__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1', 8080))
    sk.listen()
    socket_pool = Pool(5)
    while True:
        conn,addr = sk.accept()
        socket_pool.apply_async(chat,args=(conn,))

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8080))
while True:
    msg = input('请输入消息：').encode('utf-8')
    sk.send(msg)
    if msg == b'q':
        break
    ret = sk.recv(1024).decode('utf-8')
    print(ret)
sk.close()

发现：并发开启多个客户端，服务端同一时间只有4个不同的pid，只能结束一个客户端，另外一个客户端才会进来.

　　进程池可以有返回值：

from multiprocessing import Pool
def func(args):
    args += 1
    print(args)
    return args

if __name__ == '__main__':
    pool = Pool(5)
    ret = pool.map(func,range(20))#map是异步的，根据进程池大小同时运行限定的进程
                                    #  结果是func的返回值，返回一个存放计算结果的列表
    print(ret) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

from multiprocessing import Pool
import time
def func(args):
    time.sleep(1)
    args += 1
    return args

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(20):
        ret = pool.apply(func,args=(i,))#map是同步的，自带join和close方法，等待一个进程结束才进行下个进程任务
                                        #  结果是func的返回值
        print(ret) #1

from multiprocessing import Pool
import time
def func(args):
    time.sleep(1)
    args += 1
    return args

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(20):
        ret = pool.apply_async(func,args=(i,))#apply_async是同步的，需要主动使用join和close方法，才能关闭进程池。
                                        #  结果是一个存放func返回值的对象，需要调用get方法才能获取值，
                                        #而get自带阻塞，相当于join，当你一条一条获取值时，会变成同步，因为需要等待计算完毕的返回值
        print(ret.get())
    pool.close()

　　进程池的回调函数：

需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数

我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。

from multiprocessing import Pool
import os
def func(args):
    args += 1
    return args

def func2(args2): #接收子进程func的返回值
    args2 += 2
    print('我的父进程号%s'%os.getppid())
    print('我的进程号号%s'%os.getpid())#916,回调函数属于主进程
    print(args2)

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        p = pool.apply_async(func,args=(i,),callback=func2)#callback指定回调函数，将子进程的返回值返回给回调函数

    pool.close()
    pool.join()
    print('主进程号%s'%os.getpid())#916

爬虫示例:暂时跳过