线程全局修改、死锁、递归锁、信号量、GIL以及多进程和多线程的比较
线程全局修改
x = 100
def func1():
global x
print(x)
changex()
print(x)
def changex():
global x
x = 50
func1()
"""
100
50
"""
线程锁
from threading import Thread, Lock
x = 0
mutex = Lock()
def task():
global x
mutex.acquire() #加了锁之后就能保证每次只有一个运行,就不会出现数据丢失现象,不过效率会降低
for i in range(100000):
x = x + 1
"""
如果不加锁,那么(以下的情况属于假设):
t1 的 x 刚拿到0(属于IO) 保存好状态,这时候CPU切换给t2运行。
t2 的 x拿到 0 并进行+1 操作 这时候x是1(运行完CPU切换)
t1 又获得运行了 x = 0 并进行+1操作 这时候x也是1
****************************
经过上面三步,是加了2次1,而真实运算出来的应该是+2,实际上只是加了1
这就是为什么不加锁本来应该是300000,但是实际上却小于这个数的原因
这就会产生数据安全问题
"""
mutex.release()
if __name__ == '__main__':
t1 = Thread(target=task)
t2 = Thread(target=task)
t3 = Thread(target=task)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print(x)
死锁问题
from threading import Thread,Lock
lock1 = Lock()
# lock2 = lock1 #这种情况相当于只有一把锁,
# 所以抢到了锁1之后没办法再抢锁2了,就会卡在(Thread-1 抢到了锁1)
lock2 = Lock()
class DeadLock(Thread):
def run(self):
self.task1()
self.task2()
def task1(self):
lock1.acquire()
print(f'{self.name} 抢到了锁1')
lock2.acquire()
print(f'{self.name} 抢到了锁2')
lock2.release()
print(f'{self.name} 释放了锁2')
lock1.release()
print(f'{self.name} 释放了锁1')
def task2(self):
# 这里如果抢锁2,就会出现死锁现象,就会卡在这
# lock2.acquire()
# print(f'{self.name} 抢到了锁2')
# 这里如果抢锁1,就不会出现死锁现象,会一直运行下去
# lock1.acquire()
# print(f'{self.name} 抢到了锁1')
lock2.acquire()
print(f'{self.name} 抢到了锁2')
lock1.release()
print(f'{self.name} 释放了锁1')
lock2.release()
print(f'{self.name} 释放了锁2')
for i in range(3):
t = DeadLock()
t.start()
*******死锁问题********
###两个线程
# 线程1拿到了(锁2),想要往下执行需要(锁1),
# 线程2拿到了(锁1),想要往下执行需要(锁2),
# 互相都拿到了彼此想要往下执行的必需条件,互相都不放手里的锁
递归锁
from threading import Thread,RLock
'''
递归锁 在同一个线程内可以被多次acquire
如何释放 内部相当于维护了一个计数器
也就是说同一个线程 acquire了几次
就要release几次
'''
lock1 = RLock()
lock2 = lock1
class Recursion(Thread):
def run(self):
self.task1()
self.task2()
def task1(self):
lock1.acquire()
print(f'{self.name}抢到了 锁1')
lock2.acquire()
print(f'{self.name}抢到了 锁2')
lock1.release()
print(f'{self.name}释放了 锁1')
lock2.release()
print(f'{self.name}释放了 锁2')
def task2(self):
lock1.acquire()
print(f'{self.name}抢到了 锁1')
lock2.acquire()
print(f'{self.name}抢到了 锁2')
lock1.release()
print(f'{self.name}释放了 锁1')
lock2.release()
print(f'{self.name}释放了 锁2')
for i in range(3):
t = Recursion()
t.start()
#可以正常执行,不会出现差错
信号量
from threading import Thread,currentThread,Semaphore
import time
def task():
sm.acquire()
time.sleep(2)
print(f'{currentThread().name} is running!')
sm.release()
sm = Semaphore(5) #(可以一次性发5个,信号量就是自定义最大连接数5个)
for i in range(15):
t = Thread(target=task)
t.start()
"""
会分3组,
每组5个打印出来
"""
GIL(全局解释器锁)
"""
###在Cpython解释器中有一把GIL(全局解释器锁),GIL锁本质是一把互斥锁。
导致了同一个进程下,同一时间只能运行一个进程,无法利用多核优势,同一进程
下多个线程只能实现并发不能实现并行。
为什么要有GIL?
因为Cpython自带的垃圾回收机制不是线程安全的,所以要有GIL锁。
导致了同一进程下,同一时间只能运行一个线程,无法利用多核优势。
分析:
我们有四个任务需要处理,处理方式肯定要玩出并发的效果,解决方案可以是:
方案一:开启四个进程
方案二:一个进程下,开启四个线程
"""
#******计算密集型******
#推荐使用多进程
from threading import Thread
from multiprocessing import Process
import time
def work1():
res = 0
for i in range(100000000):
res *= i
if __name__ == '__main__':
t_list = []
start = time.time()
for i in range(5):
t = Process(target=work1)
# t = Thread(target=work1())
t.start()
t_list.append(t)
for t in t_list:
t.join()
end = time.time()
print('多进程', end - start) #多进程 22.06749701499939
# print('多线程', end - start) #多线程 41.195727586746216
******IO密集型******
#推荐使用多线程
from threading import Thread
from multiprocessing import Process
import time
def task1():
x = 1+1
time.sleep(3)
if __name__ == '__main__':
t_list = []
start = time.time()
for i in range(4):
# t = Thread(target=task1)
t = Process(target=task1)
t_list.append(t)
t.start()
for t in t_list:
t.join()
end = time.time()
# print('多线程', end - start) #多线程 3.002215623855591
print('多进程', end - start) #多进程 3.8354334831237793
线程全局修改、死锁、递归锁、信号量、GIL以及多进程和多线程的比较的更多相关文章
- python并发编程-多线程实现服务端并发-GIL全局解释器锁-验证python多线程是否有用-死锁-递归锁-信号量-Event事件-线程结合队列-03
目录 结合多线程实现服务端并发(不用socketserver模块) 服务端代码 客户端代码 CIL全局解释器锁****** 可能被问到的两个判断 与普通互斥锁的区别 验证python的多线程是否有用需 ...
- 并发编程---死锁||递归锁---信号量---Event事件---定时器
死锁 互斥锁:Lock(),互斥锁只能acquire一次 递归锁: RLock(),可以连续acquire多次,每acquire一次计数器+1,只有计数为0时,才能被抢到acquire # 死锁 f ...
- 同步锁 死锁与递归锁 信号量 线程queue event事件
二个需要注意的点: 1 线程抢的是GIL锁,GIL锁相当于执行权限,拿到执行权限后才能拿到互斥锁Lock,其他线程也可以抢到GIL,但如果发现Lock任然没有被释放则阻塞,即便是拿到执行权限GIL也要 ...
- 线程锁&信号量&gil
线程锁 线程锁的主要目的是防止多个线程之间出现同时抢同一个数据,这会造成数据的流失.线程锁的作用类似于进程锁,都是为了数据的安全性 下面,我将用代码来体现进程锁的作用: from threading ...
- Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量
Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量 一丶线程的理论知识 什么是线程: 1.线程是一堆指令,是操作系统调度 ...
- 并发编程~~~多线程~~~守护线程, 互斥锁, 死锁现象与递归锁, 信号量 (Semaphore), GIL全局解释器锁
一 守护线程 from threading import Thread import time def foo(): print(123) time.sleep(1) print('end123') ...
- GIL全局解释器锁-死锁与递归锁-信号量-event事件
一.全局解释器锁GIL: 官方的解释:掌握概念为主 """ In CPython, the global interpreter lock, or GIL, is a m ...
- day 7-6 GIL,死锁,递归锁与信号量,Event,queue,
摘要: 1.死锁与递归锁 2.信号量 3.Event 4.Timer 5.GIL 6.Queue 7.什么时候该用多线程和多进程 一. 死锁与递归锁 所谓死锁: 是指两个或两个以上的进程或线程在执行过 ...
- python 线程(创建2种方式,锁,死锁,递归锁,GIL锁,守护进程)
###############总结############ 线程创建的2种方式(重点) 进程:资源分配单位 线程:cpu执行单位(实体) 线程的创建和销毁的开销特别小 线程之间资源共享,是同一个 ...
随机推荐
- [最新].NET Core ORM 开源项目一览,持续更新
截至2019-05-08共收集27个 .NET Core ORM 开源项目,38个 .NET ORM 开源项目. .NET Core ORM 开源项目收集地址:https://github.com/o ...
- What programming language is best for a bioinformatics beginner?
probably Unix Shell scripts, Perl, or Python and R can be the best options. ---------- 1-python 2-R ...
- oracle数据库安装过程中的疑惑—该记录是本人以前写在微博上的文章
转行IT初学者关于oracle数据库整理第一次安装数据库的时候都是按照操作步骤一步一步进行安装,并没有对操作步骤产生过怀疑或者为什么要这么进行操作?2017年12月8日再次阅读安装操作说明书的时候有了 ...
- Clean Code 笔记 之 第二章
你是否真正的会命名 前言 这是我第二次看这本书了(Clean Code)的时候,第一次看的时候是,看到某世界五百强在他们的代码中我竟然看不到一句注释,现在我还记得当时的情景,当我Download 下第 ...
- Installing Google Chrome in Linux(RedHat Enterprise Linux 7)
# wget https://dl.google.com/linux/direct/google-chrome-stable_current_x86_64.rpm # yum -y install r ...
- Java学习:网络编程总结
Java网络编程总结 一.概述 计算机网络是通过传输介质.通信设施和网络通信协议,把分散在不同地点的计算机设备互连起来,实现资源共享和数据传输的系统.网络编程就就是编写程序使联网的两个(或多个)设备( ...
- K8S的DNS服务
k8s集群部署完后第一件事就是要配置DNS服务,目前可选的方案有skydns, kube-dns, coredns kube-dns是k8s中的一个内置插件,目前作为一个独立的开源项目维护,见http ...
- EOF的意义及用法
c/c++ 中EOF的意义及用法 EOF,为End Of File的缩写,通常在文本的最后存在此字符表示资料结束. 在微软的DOS和Windows中,读取数据时终端不会产生EOF.此时,应用程序知道数 ...
- 【linux】linux修改文件句柄数量,linux文件句柄的修改分为用户级和系统级
说明: liunx中文件句柄有两种,一种是用户级的,一种是系统级的 文件句柄限制,就是规定的单个进程能够打开的最大文件句柄数量(Socket连接也算在里面,默认大小1024) 1 用户级的修改 1.1 ...
- kafka原理详解之各种offset和checkpoint
每一个分区都是一个顺序的.不可变的消息队列,并且可以持续的添加.分区中的消息都被分配了一个序列号,称之为偏移量(offset),在每个分区中此偏移量都是唯一的.一个分区在文件系统里存储为一个文件夹.文 ...