一.manager

常用的数据类型：dict list 能够实现进程之间的数据共享

进程之间如果同时修改一个数据，会导致数据冲突，因为并发的特征，导致数据更新不同步。

def work(dic, lock):

# 简写:使用with语法自动给你上锁和解锁

with lock:

dic["count"] -= 1

'''

#上锁的正常写法

#上锁

lock.acquire()

#数据值减一

dic["conut"] -=1

# 解锁

lock.release()

'''

if __name__ == "__main__":

# 创建Manager对象

m = Manager()

# 创建一个锁对象（为了保证数据的同步）

lock = Lock()

lst = []

# 创建共享字典

dic = m.dict({"count": 100})

# 产生一百个进程。每个进程减一。

for i in range(100):

# 返回进程对象p

p = Process(target=work, args=(dic, lock))

p.start()

lst.append(p)

for i in lst:

i.join()

print(dic)

二．进程池pool

小知识点：

import os

# 计算你的机器有多少cpu

print(os.cpu_count())

1.比较pool 和Process 执行的速度

因为进程池可以实现并行的概念，比process单核并发的速度快

def func(num):

# time.sleep(3)

# time.sleep(random.uniform(0.1,1))

print("这是发送的第%d邮件" % (num))

if __name__ == "__main__":

startime = time.time()

# （1）进程池实现并行

# 创建进程对象

# pool() 里面的参数是同一个时间允许多少个进程并行

'''

4个任务

(1)1个人做4个

(2)4个人做4个

(3)4个人做1个

任务量较少时,3的速度较快,任务量较大时,2的速度更快.

因为如果任务线拉长,频繁切换cpu会占点时间.

'''

p = Pool()  #默认是电脑cpu的核数,默认的时候任务量大更好

# 1 的时候 0.2560138702392578,如果是1表示电脑核数同时执行1个进程

# 不停的更换cpu运行进程任务，这样避免cpu过热降频

for i in range(100):

p.apply_async(func, args=(i,))

# 关闭进程池，不在接收新的进程

p.close()

# 主进程阻塞，等待子进程全部完成后再退出

p.join()

endtime = time.time()

print(endtime - startime)  # 0.43866443634033203

# (2) Process 单核并发程序

startime = time.time()

lst = []

for i in range(100):

p = Process(target=func,args=(i,))

p.start()

lst.append(p)

for i in lst:

i.join()

endtime = time.time()

print(endtime-startime) # 8.061640739440918

2.apply 开启进程（未来可能去掉）

同步阻塞，每次都要等待当前任务完成之后，在开启下一个进程，可加上返回值。

def task(num):

time.sleep(random.uniform(0.1,1)) # 同步程序

print("%s:%s" % (num,os.getpid()))

return num

if __name__ == "__main__":

p = Pool()

for i in range(20):

res = p.apply(task,args=(i,))

print("-->",res)

# 完完全全的同步程序，等上面走完了再执行finish

print("finish")

同一时间只有4个进程。

3.apply_async 异步非阻塞程序 可以有返回值

Process 产生的子进程,默认主进程等待所有子进程执行完毕之后再终止

而Pool进程池,只要主进程跑完了,立刻终止所有程序

未来避免还没有执行就结束，进程time.sleep  和使用join守护。

例：

def task(num):

#time.sleep(3)

time.sleep(random.uniform(0.1,1)) #同步程序

print("%s:%s" %(num,os.getpid()))

return os.getpid()

if __name__ == "__main__":

p = Pool()

lst = []

lst2 = []

for i in range(20):

res = p.apply_async(task,args=(i,))  # res 是对象

# print(res)

# 1.把返回的对象一个一个插入到列表里

lst.append(res)

for i in lst:

# 2.使用get方法获取返回值

lst2.append(i.get())

# 关闭进程池.不在接受新的进程

p.close()

# 主进程阻塞,等待 子进程全部完成后再退出

p.join()

# 主进程阻塞,等待进程全部完成后再退出

# 返回的是默认 4个进程,因为当期机器是4个核心cpu

print(set(lst2),len(set(lst2)))

print("finish")

4.进程池.map

(与高阶函数map使用方法一样,只不过该map支持并行并发)

# 进程池.map 返回的是列表

# map默认底层中加了阻塞,等全部执行完毕之后,主进程在终止程序,区别于3

例：

if __name__ == "__main__":

p = Pool()

lst = p.map(task, range(100))

print(lst)

# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801]

# 如果出现了join,一定需要加上close,要么同时出现,要么都没有

# p.close()

# p.join()

print(123455)

5.关闭进程池

关闭进程池,不会再接受新的进程

例：

def task(num):

time.sleep(random.uniform(0.1,1))

print("%s:%s" % (num,os.getpid()))

return num ** 2

if __name__ == "__main__":

p = Pool()

lst= []

for i in range(20):

res = p.apply_async(task,args=(i,))

lst.append(res)

# get 函数内部默认加了阻塞,获取完所有值之后再向下执行

for i in lst:

print(i.get())

p.close()

# 如果执行close,不能够继续往进程池里面加进程了

# res = p.apply_async(task,args=(112233,))

p.join()

print("finish")

去掉程序例：  # res = p.apply_async(task,args=(112233,))的注释就出现想要的结果：