数据共享,回调函数,threading模块,守护线程

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('主程序结束')