多进程学习

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @createTime    : 18-5-22 下午8:23
# @author  : mm
import multiprocessing
import threading
import time
from multiprocessing.dummy import Process


def f0(a1):#子进程
    time.sleep(3)
    print(a1)
if __name__ == '__main__':#windows下必须加这句

    t = multiprocessing.Process(target=f0,args=(12,))  #主进程
    t.daemon=True#将daemon设置为True，则主线程不比等待子进程，主线程结束则所有结束
    # t.start()

    t2 = multiprocessing.Process(target=f0, args=(13,))
    # t2.daemon = True
    t2.start()

    print('end')#默认情况下等待所有子进程结束，主进程才结束



# (2)进程之间默认是不能共用内存的
li = []
def f1(i):
    li.append(i)
    print('haha',li)

if __name__ =='__main__':#进程不能共用内存
    for i in range(10):
        p = Process(target=f1,args=(i,))
        p.start()
        p.join()

# 如果不加p.join()，得到的结果：
# ('haha', ('haha', [[0, 0('haha', , 1[01, 2], , )
# 1('haha'2, 2, , [0, 33]], )
# (1, ')h
# 2, 3, 4])
# aha', [0('haha', [0, 1, 2, 1, 3, 2(, , 3'haha', , 4, 4[5, (, 65, 0, 6'h, , aha'717, ], (, [8'ha0, )1ha'2,
# [0, 3, 4, ]5, ), ('h1aha'
# 2, , , 6, [, 3, 4, 05, 6, 21, 3, , 7, 7, 42, , 388, , , 5, 649], 9)]),
#
# , 5, 6, 77, 8, , 9]8, 9)
# ])
# 如果加p.join()，得到的结果：
# ('haha', [0])
# ('haha', [0, 1])
# ('haha', [0, 1, 2])
# ('haha', [0, 1, 2, 3])
# ('haha', [0, 1, 2, 3, 4])
# ('haha', [0, 1, 2, 3, 4, 5])
# ('haha', [0, 1, 2, 3, 4, 5, 6])
# ('haha', [0, 1, 2, 3, 4, 5, 6, 7])
# ('haha', [0, 1, 2, 3, 4, 5, 6, 7, 8])
# ('haha', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 如果将代码改成threading，由于线程共用内存，所以结果是不一样的，线程操作列表li之前，拿到的是前一个线程操作过的li列表，如图
#多线程不需要join得到的结果一样。

li = []
def f1(i):
    li.append(i)
    print('haha',li)

if __name__ =='__main__':#进程不能共用内存
    for i in range(10):
        p = threading.Thread(target=f1,args=(i,))
        p.start()


#(3)如果要进程之间处理同一个数据，可以运用数组以及进程里面的manager方法，下面代码介绍的是manager方法
from multiprocessing import Process
from multiprocessing import Manager



def f1(i,dic):#运用manage之后，会在原dic基础上添加新的键值
    dic[i] = 200+i
    print(dic.values())

# if __name__ =='__main__':#进程间默认不能共用内存  ？？？理解？？
#     manager = Manager()
#     dic = manager.dict()#这是一个特殊的字典，
#     for i in range(10):
#         p = Process(target=f1,args=(i,dic))
#         p.start()
#         p.join()
#结果：
# [200]
# [200, 201]
# [200, 201, 202]
# [200, 201, 202, 203]
# [200, 201, 202, 203, 204]
# [200, 201, 202, 203, 204, 205]
# [200, 201, 202, 203, 204, 205, 206]
# [200, 201, 202, 203, 204, 205, 206, 207]
# [200, 201, 202, 203, 204, 205, 206, 207, 208]
# [200, 201, 202, 203, 204, 205, 206, 207, 208, 209]
#(3.2）如果是普通的字典，如下：
# if __name__ =='__main__':#进程间默认不能共用内存
#     # manager = Manager()
#     # dic = manager.dict()#这是一个特殊的字典
#     dic = {} #普通的字典，#不会在原dic基础上添加新的键值，而是每次都新建一个字典，每次覆盖前面一个；
#     for i in range(10):
#         p = Process(target=f1,args=(i,dic))
#         p.start()
#         p.join()
# 结果：
# [200]
# [201]
# [202]
# [203]
# [204]
# [205]
# [206]
# [207]
# [208]
# [209]

# 4、multiprocessing模块里面的进程池Pool的使用
#
# （1）apply模块的使用，每个任务是排队执行的
from multiprocessing import Process,Pool
from multiprocessing import Manager
import time


def f1(a):
    time.sleep(2)
    print(a)

if __name__ =='__main__':
    pool =Pool(5)
    for i in range(5):#每次使用的时候会去进程池里面申请一个进程
        pool.apply(func=f1,args=(i,))
        print('你好')#apply里面是每个进程执行完毕了才执行下一个进程
    pool.close()#执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    pool.join()#等待进程运行完毕，先调用close函数，否则会出错
#结果：
# 0
# 你好
# 1
# 你好
# 2
# 你好
# 3
# 你好
# 4
# 你好
# （2）apply_async模块，会比apply模块多个回调函数，同时是异步的
from multiprocessing import Process,Pool
from multiprocessing import Manager
import time



def Foo(i):
    time.sleep(1)
    return i+50

def Bar(arg):
    print(arg)

if __name__ =='__main__':
    pool = Pool(5)
    for i in range(10):

        '''apply是去简单的去执行，而apply_async是执行完毕之后可以执行一
        个回调函数，起提示作用'''
        pool.apply_async(func=Foo,args=(i,),callback=Bar)#是异步的
        print('你好')
    pool.close()#不执行close会报错，因为join的源码里面有个断言会检验是否执行了该方法
    pool.join()#等待所有子进程运行完毕，否则的话由于apply_async里面daemon是设置为True的，主进程不会等子进程，所欲函数可能会来不及执行完毕就结束了
'''apply_async里面，等函数Foo执行完毕，它的返回结果会被当做参数
    传给Bar'''
# 结果：
# 你好
# 你好
# 你好
# 你好
# 你好
# 你好
# 你好
# 你好
# 你好
# 你好
# 50
# 51
# 52
# 54
# 53
# 55
# 56
# 57
# 59
# 58