1,数据共享:from multiprocessing import Manager
把所有实现了数据共享的比较便捷的类都重新又封装了一遍,并且在原有的multiprocessing基础上
增加了新的机制 :dict ,list
2数据共享的机制:
支持的数据类型非常有限
list,dict数据是不安全的,需要通过加锁来保证数据安全
from multiprocessing import Manager,Process,Lock
def work(d,lock):
with lock:
d['count'] -= 1
if __name__ == '__main__':
lock = Lock()
with Manager() as m:
dic = m.dict({'count':100})
p_l = []
for i in range(100):
p = Process(target=work,args=(dic,lock))
p.start()
p_l.append(p)
for p in p_l:
p.join()
print(dic)
3:回调函数:
当func执行完毕之后执行callback的参数
func的返回值会作为callback的参数
回调函数是哪个进程实现的? --主进程
子进程有大量的计算要去做,回调函数等待结果做简单的处理,可交由主进程进行
from multiprocessing import Pool
def func(a):
num = a
return num
def callback(x):
y = x**2
print(y)
if __name__ == '__main__':
p = Pool()
print('主进程')
p.apply_async(func,args=(100,),callback=callback)
p.close()
p.join()
4.线程理论:
进程是什么:
计算机中分配资源的最小单位,是计算机中正在执行的程序
进程对操作系统有一定的负担,操作系统要分配给一个进行的资源大致有:代码,数据,文件
线程是什么:
线程是计算机中被CPU调度的最小单位,
进程与线程之间的关系:
一个进程中都有一个线程
线程是不能独立存在的,他没有属于自己的进程资源
线程的特点:
同一进程中的所有的线程的资源是共享的
轻量级,自己的资源
线程与进程之间的区别:
占用的资源
调度的效率
资源是否共享:进程与进程之间的资源是不共享的,同一进程中的所有的线程的资源四共享的
一个进程中的所有线程是否能够并行:
不行:Cpython解释器内部有一把全局解释器锁:GIL
所以线程不能充分利用多核
同一时刻同一个进程中的线程只有一个会被CPU调度
GIL锁 确实限制了程序的效率,提高了数据的安全性
GIL锁 目前是能够帮助线程在切换中提高效率
5.threading 模块:
并发
from threading import Thread
def func(i):
print(i)
print('主进程')
for i in range(10):
t = Thread(target=func,args=(i,))
t.start()
轻量级:线程比进程耗时少
import time
import random
from threading import Thread
from multiprocessing import Process
def func(i):
print(i)
time.sleep(random.random())
# if __name__ == '__main__':
# t_lst = []
# start = time.time()
# for i in range(1000):
# t = Thread(target=func,args=(i,))
# t.start()
# t_lst.append(t)
# for t in t_lst:
# t.join()
# print(time.time() - start)
if __name__ == '__main__':
p_lst = []
start = time.time()
for i in range(1000):
p = Process(target=func,args=(i,))
p.start()
p_lst.append(p)
for p in p_lst:
p.join()
print(time.time() - start)
数据共享:
from threading import Thread
num = 100
def func():
global num
num -= 1
t_lst = []
for i in range(100):
t = Thread(target=func)
t.start()
t_lst.append(t)
for t in t_lst:
t.join()
print(num)
import time
from threading import Thread
def func():
time.sleep(3)
t = Thread(target=func)
t.start()
print(t.is_alive()) #查看线程是否活着
print(t.getName()) #查看线程名字
# print(t.setName('t1'))#修改线程名字
6:守护线程:
守护线程 是在主程序代码结束之后,还等待了子进程执行结束才结束
主线程结束意味着主进程结束
主线程等待所有的线程结束
主线程结束了之后,守护线程随着主进程的结束自然结束了.
import time
from threading import Thread
def func():
while True:
time.sleep(0.5)
print(123456)
def func1():
print('666')
time.sleep(3)
print('4444')
t = Thread(target=func)
t1 = Thread(target=func1)
t1.setDaemon(True)
t.start()
t1.start()
print('主程序结束')