036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量

笔记

昨日内容回顾:

队列: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 Processdef 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, Semaphoredef 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 Processnum = 100
def func():global numnum = 0if __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 = Truep2.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,Lockclass MyThread(Thread):def __init__(self,lockA,lockB):super().__init__()self.lockA = lockAself.lockB = lockBdef 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 -= 1t_lock.acquire()mid = nummid = mid - 1time.sleep(0.0001)num = midt_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 Processdef func(n):num = 0for n1 in range(n):num += n1print('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 = lockAself.lockB = lockBdef 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('我是经理')

036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量相关推荐

线程的创建验证线程之间共享数据守护线程线程进程效率对比锁死锁递归锁...
线程(from threading import Thread):CPU调度的最小单位线程的两种创建方式:方式一: 1 from threading import Thread 2 def f1(i ...
黑马程序员--线程之间的通信，等待与唤醒机制，线程的终止方式，线程中的其他方法，优先级，toString() 守护线程，GUI图形化界面
------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS ...
java回调函数的生命_Java车票，车站，生命周期，龟兔赛跑，同步锁，礼让，守护线程，挖金矿【诗书画唱】...
个人理解:加同步锁等的时候,就可以让线程"按顺序排队",一个一个地抢CPU,一个抢完对应的每次有的CPU了,另一个才抢对应的每次有的CPU,解决"并发"问题等. ...
python-同步（互斥）锁、递归锁、同步条件（event）
同步:接打电话异步:收发短信同步锁:threading.lock() 递归锁:threading.Llock() #计数器机制,只要计数器counter>0,其他线程无法竞争到CPU资源 ...
python-GIL、死锁递归锁及线程补充
一.GIL介绍 GIL全称 Global Interpreter Lock ,中文解释为全局解释器锁.它并不是Python的特性,而是在实现python的主流Cpython解释器时所引入的一个概念,G ...
java线程同步的死锁_Java基础之线程5-线程同步死锁
死锁:线程之间因条件相互竞争,导致线程都不能正常执行完,从而产生了死锁. 死锁的例子: public class TestDeadLock implements Runnable { public i ...
进程间的数据共享、进程池的回调函数和线程初识、守护线程
一.进程的数据共享进程间数据是独立的,可以借助于队列或管道实现通信,二者都是基于消息传递的虽然进程间数据独立,但可以通过Manager实现数据共享.把所有实现了数据共享的比较便捷的类都重新又封装了 ...
Java：多线程（同步死锁、锁原子变量、线程通信、线程池）
5,同步和死锁 5.1,线程同步修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象: 修饰一个方法,被修饰的方法称为同步方法,其作用 ...
数据共享,回调函数,threading模块,守护线程
1,数据共享:from multiprocessing import Manager 把所有实现了数据共享的比较便捷的类都重新又封装了一遍,并且在原有的multiprocessing基础上增加了新的 ...

036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量

036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量相关推荐

最新文章

热门文章

036-2018-1028 线程 效率对比 数据共享 同步锁死锁递归锁 守护线程 信号量

036-2018-1028 线程 效率对比 数据共享 同步锁死锁递归锁 守护线程 信号量相关推荐

最新文章

热门文章

036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量

036-2018-1028 线程效率对比数据共享同步锁死锁递归锁守护线程信号量相关推荐