笔记
昨日内容回顾:
队列:Queue
管道 : Pipe ,recv消息的时候 OSError,EOFError,数据不安全的
Manager : 共享数据 , 数据不安全 , 加锁
进程池 :
P = Pool()
Map(function,iter-obj) #异步,自带join: 主进程等待map里面任务结束
Apply : 同步执行,串行,一个完了一个的执行,效率低, 直接就能拿到返回值
Apply_async() : 异步执行任务,异步的最大量是你进程池中进程的个数
Join:等待进程池中的任务全部执行完毕
Close:由于我们想看看进程池中现有的任务是否全部运行完毕,或者说我想获取进程池中当前所有任务的结果,我们需要等待全部任务执行完毕,但是可能会有新的任务进来,所以没办法确定我现有的任务是多少,我要等他完,但是有新任务一直进来就完不了,所有我们要锁定进程池,不让其他任务进来.使用close
Callback
Close()
Join()
线程:
今日内容:
线程 #什么是线程:
线程和进程的效率对比:线程的效率非常高,并且线程开启不需要消耗什么资源
线程之间数据共享:
锁(同步锁\互斥锁):保证数据安全,但是牺牲了效率,同步执行锁内的代码
死锁现象 : 互相抢到了对方的需要的锁,导致双方相互等待,程序没法进行
解决死锁:递归锁,RLock #可以多次acquire,通过一个计数器来记录被锁了多少次,只有计数器为0的时候,大家才能继续抢锁
守护进程 :
主进程代码结束程序并没有结束,并且主进程还存在,进程等待其他的子进程执行结束以后,为子进程收尸,注意一个问题:主进程的代码运行结束守护进程跟着结束,
守护线程:
主线程等待所有非守护线程的结束才结束,主线程的代码运行结束,还要等待非守护线程的执行完毕.这个过程中守护线程还存在
信号量:控制同时能够进入锁内去执行代码的线程数量(进程数量),维护了一个计数器,刚开始创建信号量的时候假如设置的是4个房间,进入一次acquire就减1 ,出来一个就+1,如果计数器为0,那么其他的任务等待,这样其他的任务和正在执行的任务是一个同步的状态,而进入acquire里面去执行的那4个任务是异步执行的.
大宝剑!!!
在有时间:GIL
明日预习内容
https://www.cnblogs.com/clschao/articles/9684694.html
作业:
主线程等待子线程的原因.py
import time
from threading import Thread
from multiprocessing import Process
def func(n):
time.sleep(5)
print(n)
if __name__ == '__main__':
# 主线程等待的是子线程的任务全部执行完毕
t = Thread(target=func, args=('我是子线程',))
t.start() # 速度非常快
# 主进程等待的是给子进程收尸
# p = Process(target=func,args=('我是子进程',))
# p.start()
# print('主进程结束!!')
print('主线程结束')信号量.py
import time
from threading import Thread, Semaphore
def func1(s):
s.acquire()
time.sleep(1)
print('大宝剑!!!')
s.release()
if __name__ == '__main__':
s = Semaphore(4)
for i in range(10):
t = Thread(target=func1,args=(s,))
t.start()
同一进程下线程是资源共享的.py
import time
from threading import Thread
from multiprocessing import Process
num = 100
def func():
global num
num = 0
if __name__ == '__main__':
t = Thread(target=func,)
t.start()
t.join()
print(num)
守护线程.py
import time
from threading import Thread
from multiprocessing import Process
def func1(n):
time.sleep(5)
print(n)
def func2(n):
time.sleep(3)
print(n)
if __name__ == '__main__':
p1 = Process(target=func1,args=('我是子进程1号',))
p1.daemon = True #设置守护,在start之前加
p1.start()
p2 = Process(target=func2, args=('我是子进程2号',))
# p2.daemon = True
p2.start()
# t1 = Thread(target=func1, args=('我是子xiancheng1号',))
# t1.daemon = True
# t1.start()
# t2 = Thread(target=func2, args=('我是子xiancheng2号',))
# t2.start()
time.sleep(1)
print('主进程结束!!')
# print('主线程结束')
死锁现象.py
import time
from threading import Thread,Lock
class MyThread(Thread):
def __init__(self,lockA,lockB):
super().__init__()
self.lockA = lockA
self.lockB = lockB
def run(self):
self.f1()
self.f2()
def f1(self):
self.lockA.acquire()
print('我拿了A锁')
self.lockB.acquire()
print('我是一个很好的客户!')
self.lockB.release()
self.lockA.release()
def f2(self):
self.lockB.acquire()
time.sleep(0.1)
print('我拿到了B锁')
self.lockA.acquire()
print('我是一名合格的技师')
self.lockA.release()
self.lockB.release()
if __name__ == '__main__':
lockA = Lock()
lockB = Lock()
t1 = MyThread(lockA,lockB)
t1.start()
t2 = MyThread(lockA,lockB)
t2.start()
print('我是经理')
线程创建.py
import time
from threading import Thread
from multiprocessing import Process
#
# def func(n):
# print(n)
#
# if __name__ == '__main__':
# # t = Thread(target=func,args=('我是线程',))
# # t.start() #速度非常快
# p = Process(target=func,args=('我是进程',))
# p.start()
# print('主线程结束')
# class MyThread(Thread):
#
# def run(self):
# print('sb明杰')
#
# if __name__ == '__main__':
# t = MyThread()
# t.start()
# print('主线程结束')
线程资源共享数据不安全.py
# 锁
import time
from threading import Thread,Lock
#演示共享资源的时候,数据不安全的问题
# num = 100
# def func():
# global num
# # num -= 1
# mid = num
# mid = mid - 1
# time.sleep(0.0001)
# num = mid
# if __name__ == '__main__':
#
# t_list = []
# for i in range(10):
# t = Thread(target=func,)
# t.start()
# t_list.append(t)
# [tt.join() for tt in t_list]
# print('主线程>>>',num)
#通过锁来解决数据不安全的问题,线程模块里面引入的锁
num = 100
def func(t_lock):
global num
# num -= 1
t_lock.acquire()
mid = num
mid = mid - 1
time.sleep(0.0001)
num = mid
t_lock.release()
if __name__ == '__main__':
t_lock = Lock() #锁对象(同步锁,互斥锁)
t_list = []
for i in range(10):
t = Thread(target=func,args=(t_lock,))
t.start()
t_list.append(t)
[tt.join() for tt in t_list]
print('主线程>>>',num)
线程进程效率对比.py
import time
from threading import Thread
from multiprocessing import Process
def func(n):
num = 0
for n1 in range(n):
num += n1
print('num',num)
if __name__ == '__main__':
t_s_t = time.time()
t_list = []
for i in range(10):
t = Thread(target=func,args=(10,))
t.start() #速度非常快
t_list.append(t)
[tt.join() for tt in t_list]
t_e_t = time.time()
t_dif_t = t_e_t - t_s_t #获取了线程的执行时间
p_s_t = time.time() #开始时间
p_list = []
for ii in range(10):
p = Process(target=func,args=(10,))
p.start()
p_list.append(p)
[pp.join() for pp in p_list]
p_e_t = time.time() #结束时间
p_dif_t = p_e_t - p_s_t #时间差
print('线程>>>>',t_dif_t)
print('进程....',p_dif_t)
print('主线程结束')
解决死锁线程 递归锁.py
import time
from threading import Thread,Lock,RLock #递归锁
class MyThread(Thread):
def __init__(self,lockA,lockB):
super().__init__()
self.lockA = lockA
self.lockB = lockB
def run(self):
self.f1()
self.f2()
def f1(self):
self.lockA.acquire()
print('我拿了A锁')
self.lockB.acquire()
print('我是一个很好的客户!')
self.lockB.release()
self.lockA.release()
def f2(self):
self.lockB.acquire()
time.sleep(0.1)
print('我拿到了B锁')
self.lockA.acquire()
print('我是一名合格的技师')
self.lockA.release()
self.lockB.release()
if __name__ == '__main__':
# lockA = Lock()
# lockB = Lock()
# lockA = lockB = Lock() #不要这么写,别自己玩自己,锁自己
lockA = lockB = RLock()
t1 = MyThread(lockA,lockB)
t1.start()
t2 = MyThread(lockA,lockB)
t2.start()
print('我是经理')