Python中并发多线程等
Posted Python爱好者666
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python中并发多线程等相关的知识,希望对你有一定的参考价值。
1、基本概念
并发和并行的区别:
1)并行,parallel
同时做某些事,可以互不干扰的同一时刻做几件事。(解决并发的一种方法)
高速公路多个车道,车辆都在跑。同一时刻。
2)并发 concurrency
同时做某些事,一个时段内有事情要处理。(遇到的问题)
高并发,同一时刻内,有很多事情要处理。
2、并发的解决
1)队列、缓冲区
排队就是把人排成队列,先进先出,解决了资源使用的问题。
排成的队列,其实就是一个缓冲地带,就是缓冲区。
Queue模块的类queue、lifoqueue、priorityqueue。
2)争抢的
会有一个人占据窗口,其他人会继续争抢,可以锁定窗口,窗口不在为其他人服务,这就是锁机制。(锁的概念,排他性锁,非排他性锁)。
3)预处理
一种提前加载用户需要的数据的思路,预处理思想,缓存常用。
4)并行
日常可以通过购买更多的服务器,或者开多线程,实现并行处理,来解决并发问题。
水平扩展思想。
如果在但CPU上处理,就不是并行了。
但是多数服务都是多CPU的,服务的部署就是多机、分布式的,都是并行处理。
(串行比并行快)
5)提速
提高单个CPU性能,或单个服务器安装更多的CPU
这就是一种垂直扩展思想。
6)消息中间件
例如地跌站外的九曲回肠的走廊,缓冲人流。
常见的消息中间件有RabbitMQ,ActiveMQ(Apache)、RocketMQ(Apache)。
3、进程和线程
在实现了线程的操作系统中,线程是操作系统能够进行运算调度的最小单位。他包含在进程中,是进程中的实际运作单位。一个程序执行实例就是一个进程。
进程(process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。
(可执行,可运行的加载到内存中。程序是有一定格式的,Python解释器加载,所有进程都是有入口的。偏移多少位。主线程达不到要求,就会启用多线程。
多核。调度到不同的CPU上面去,虚拟的计算单元。)
资源争抢问题:锁,排他性锁。队列,不争抢的人排队。预加载,减少数据处理速度,提前加载到内存中。一变多。
进程和程序的关系
程序是源代码编译后的文件,而这些文件存放在磁盘上。当程序被操作系统加载到内存
中,就是进程,进程中存放着指令和数据(资源),也是线程的容器。
Linux进程有父进程、子进程,Windows的进程是平等关系。
线程,有时被称为轻量级进程,是程序执行流的最小单元,一个标准的线程由线程ID,当前指令指针(pc),寄存器集合和堆栈组成。每个线程有自己独立的栈。
在许多系统中,创建一个线程比创建一个进程快10-100倍。
进程、线程的理解
现代操作系统提出的进程的概念,每一个进程都认为自己是独占所有的计算机硬件资源。
进程就是独立的王国,进程间不可以随便的共享数据。
线程就是省份,同一个进程内的线程可以共享进程的资源,每一个线程拥有自己独立的堆栈。
4、线程状态
状态 |
含义 |
就绪(ready) |
线程能够运行,但在等待被调度,可能线程刚刚创建启动,或刚刚从阻塞恢复,或者被其他线程抢占。 |
运行(running) |
线程正在运行 |
阻塞(Blocked) |
线程等待外部事件发生而无法运行,如I/O操作。 |
终止(Terminated) |
线程完成,或退出,或被取消。 |
5、Python中的线程和进程
进程会启动一个解释器进程,线程会共享一个解释器进程。
1)Python的线程开发
Python的线程开发使用标准库threading
2)Thread类
签名:
def __init__(self, group: None = ...,
target: Optional[Callable[..., None]] = ...,
name: Optional[str] = ...,
args: Iterable = ...,
kwargs: Mapping[str, Any] = ...,
*, daemon: Optional[bool] = ...) -> None: ...
参数名 |
含义 |
target |
线程调用对象,就是目标函数 |
name |
为线程起名字 |
args |
为目标函数传递实参,元组 |
Kwargs |
为目标函数关键词传参,字典 |
3)线程启动
import threading
import time
def worker():
print(‘before‘)
time.sleep(3)
print(‘finished‘)
t = threading.Thread(target=worker) #线程对象
t.start() #启动
通过threading.Thread创建一个线程对象,target是目标函数,name可以指定名称。
需要调用start方法启动函数。
线程之所以执行函数,是因为线程中就是用来执行代码的,所以还是函数调用。
函数执行完毕后,线程也就退出了。
如果想让一个线程一直工作,不让线程退出就要利用到while循环。
import threading
import time
def worker():
count = 0
while True:
count += 1
print(‘before‘)
time.sleep(3)
if count >5:
print(‘finished‘)
break
t = threading.Thread(target=worker) #线程对象
t.start() #启动
4)线程退出
Python中没有提供终止线程的方法。线程在下面情况下退出。
(1)线程函数内语句执行完毕
(2)线程函数中抛出未处理的异常。
import threading
import time
def worker():
count = 0
while True:
if count >5:
break
#return
#raise RuntimeError(count)
time.sleep(3)
print(‘before‘)
count += 1
print(‘finished‘)
t = threading.Thread(target=worker) #线程对象
t.start() #启动
print(‘end‘)
线程没有优先级,没有线程组的概念。也不能被销毁、停止、挂起,那么就是没有恢复和中断了。
5)线程的传参
import threading
import time
def add(x,y):
print(‘{}+{}={}‘.format(x,y,x+y))
t1 = threading.Thread(target=add,name=‘1‘,args=(4,5))
t1.start()
time.sleep(2)
t2 = threading.Thread(target=add,name = ‘2‘,args=(4,),kwargs={‘y‘:6})
t2.start()
time.sleep(2)
t3 = threading.Thread(target=add,name=‘3‘,kwargs={‘x‘:4,‘y‘:7})
t3.start()
线程中的传参,和函数传参没有什么区别,本质上就是函数传承。
6)threading的属性和方法
名称 |
含义 |
current_thread() |
返回当前主线程 |
main_thread() |
返回主线程对象 |
active_count() |
当前处于alive状态的线程个数 |
enumerate() |
返回所有活着的线程的列表,不包括已经终止的线程和未开始的线程 |
git_ident() |
返回当前线程的ID,非0整数。 |
active_count、enumerate方法返回的值还包括主线程。
import threading
import time
def showinfo():
print(‘currentthread = {}‘.format(threading.current_thread()))
print(‘main thread = {}‘.format(threading.main_thread()))
print(‘active count = {}‘.format(threading.active_count()))
def worker():
count = 0
showinfo()
while True:
if count>5:
break
time.sleep(5)
count += 1
print(‘finsh‘)
t = threading.Thread(target=worker,name=‘work‘)
showinfo()
t.start()
print(‘end‘)
currentthread = <_MainThread(MainThread, started 4048)>
main thread = <_MainThread(MainThread, started 4048)>
active count = 1
currentthread = <Thread(work, started 9084)>
end
main thread = <_MainThread(MainThread, stopped 4048)>
active count = 2
finsh
finsh
finsh
finsh
finsh
Finsh
名称 |
含义 |
Name |
他只是一个名字,只是一个标识符,名字可以重名,getname()获取,setname()设置这个名词 |
Ident |
线程id,是非0的整数,线程启动后才会有ID,否则为None,线程退出,此id依旧可以访问,此id可以重复访问。 |
Is_alive() |
返回线程是否或者 |
线程的name只是一个名称,可以重复;id必须唯一,但可以在线程退出后在利用。
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(2)
count += 1
print(threading.current_thread().name)
t = threading.Thread(name=‘work‘,target=worker)
print(t.ident)
t.start()
while True:
time.sleep(1)
if t.is_alive():
print(‘{}{}alive‘.format(t.name,t.ident))
else:
print(‘{}{}dead‘.format(t.name,t.ident))
名称 |
含义 |
Start() |
启动线程,每一个线程必须且只能执行该方法一次 |
Run() |
运行线程函数 |
Start()启动线程,只能执行一次。操作系统。开辟新的线程。
Run()直接做的是主线程。函数调用。
(1)start()
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(3)
count += 1
print(‘running‘)
class Mythread(threading.Thread):
def start(self):
print(‘start----‘)
super().start()
def run(self):
print(‘run----‘)
super().run()
t = Mythread(target=worker,name=‘work‘)
t.start()
start方法运行结果是start----
run----
Running
按照线程进行执行。
(2)run()
import threading
import time
def worker():
count = 0
while True:
if count>3:
break
time.sleep(2)
count += 1
print(‘runing‘)
class Mythread(threading.Thread):
def start(self):
print(‘start----‘)
super().start()
def run(self):
print(‘run----‘)
super().run()
t = Mythread(target=worker,name=‘work1‘)
t.run()
# run----
# runing
总结:run()执行结果就是直接是函数,调用,调用run函数。
Start()方法会调用run()方法,而run()方法可以运行函数。
(3)start和run的区别
Start方法启动线程,启动了一个新的线程,名字叫做worker运行,但是run方法,并没有启动新的线程,只是在主线程内调用了一个普通的函数。
7)多线程
多线程,一个进程中如果有多个线程,就是多线程,是先一种并发。
import threading
import time
def worker():
count = 0
while True:
if count>3:
break
time.sleep(2)
count += 1
print(‘runing‘)
print(threading.current_thread().name,threading.current_thread().ident)
class Mythread(threading.Thread):
def start(self):
print(‘start----‘)
super().start()
def run(self):
print(‘run----‘)
super().run()
t1 = Mythread(target=worker,name=‘work1‘)
t2 = Mythread(target=worker,name=‘work2‘)
# t1.run()
# t2.run()
####runing
# MainThread 1380
# runing
# MainThread 1380
# runing
# MainThread 1380
t1.start()
t2.start()
# start----
# run----
# start----
# run----
# runing
# work2 5048
# runing
# work1 9048
Start()方法work1和work2交替执行。启动线程后,进程内多个活动的线程并行工作,就是多线程。
Run()方法中没有开启新的线程,就是普通函数调用,所以执行完t1.run()
,然后执行t2.run(),run()方法就不是多线程。
一个进程中至少有一个线程,并作为程序的入口,这个线程就是主线程,一个线程必须有一个主线程。
其他线程成为工作线程。
8)线程安全
import threading
def worker():
for x in range(100):
print(‘{}is running‘.format(threading.current_thread().name))
for x in range(1,4):
name = ‘worker{}‘.format(x)
t = threading.Thread(name=name,target=worker)
t.start()
利用ipython执行的结果是不是一行行的打印,而是很多字符串打印在了一起。
这样说明了print函数被打断了,被线程切换打断了,print函数分为两步,第一步是打印字符串,第二部是换行,就在这个期间,发生了线程的切换,说明了print函数是线程不安全的。
线程安全:线程执行一段代码,不会产生不确定的结果,那么这段代码是线程安全的。
也是要用锁,进程的锁是管进程内的线程。独占资源。
解决上面打印的问题:
(1)不让print打印换行
import threading
def worker():
for x in range(100):
print(‘{} is running. ‘.format(threading.current_thread().name),end=‘‘)
for x in range(1,5):
name = ‘worker{}‘.format(x)
t = threading.Thread(name=name,target=worker)
t.start()
利用字符串是不可变类型,可以作为一个整体不可分割输出,end=’’就不在print输出换行了。
(2)使用logging
标准库里面的logging模块,是日志处理模块,线程安全的,生产环境代码都使用logging。
import threading
import logging
def worker():
for x in range(100):
# print(‘{} is running. ‘.format(threading.current_thread().name),end=‘‘)
logging.warning(‘{}is running‘.format(threading.current_thread().name))
for x in range(1,5):
name = ‘worker{}‘.format(x)
t = threading.Thread(name=name,target=worker)
t.start()
9)daemon线程和non-daemon线程
daemon不是Linux里面的守护进程。
进程靠线程执行代码,至少有一个主线程,其他线程是工作线程。
主线程是第一个启动的线程。
父线程:如果A中启动了一个线程B,那么A就是B的父线程。
子线程:B就是A的子线程。
源码Thread的__init__ 方法中。
If deamon is not None:
Self._daemonic = daemon
else:
Self._daemonic = current_thread().daemon
Self._ident = None
线程daemon属性,如果设定就是用户的设置,否则,就取当前线程的daemon的值。
主线程是non-daemon线程,即daemon = False。
import time
import threading
def foo():
time.sleep(5)
for i in range(20):
print(i)
t = threading.Thread(target=foo,daemon=False)
t.start()
print(‘end‘)
daemon设置False值,主线程执行完毕后,等待工作线程。
import time
import threading
def foo():
time.sleep(5)
for i in range(20):
print(i)
t = threading.Thread(target=foo,daemon=True)
t.start()
print(‘end‘)
Daemon值改为true,主线程执行完毕后直接退出。
名称 |
含义 |
Daemon |
表示线程是否是daemon,这个值必须在start()之前设置,否则引发RuntimeError异常 |
IsDaemon() |
是否是daemon线程 |
SetDaemon |
设置daemon线程,必须在start方法之前设置。 |
总结:线程具有一个daemon属性,可以显示设置为True或者False,也可以不设置,则取默认值None。
如果不设置daemon,就取当前线程的daemon来设置他。
主线程是non-daemon线程,即daemon = False。
从主线程创建的所有线程的不设置daemon属性,则默认daemon = False,也就是non-daemon线程。
程序在没有活着的non-daemon线程运行时推出,也是就剩下的只是daemon线程,主线程才能推出。否则主线程只能等待。
构造线程的时候,可以设置daemon属性,这个属性必须在start方法前设置好。
daemon=True主线程不等。工作线程
daemon=False主线程等。只要有一个non-daemon就会等待。
控制一个属性的。
在start之前。
只是有一个non-daemon就会等待,没有的话直接不等,直接结束线程。
总结:
线程具有daemon属性,可以设置为True或者False。
(激活的non-daemon,主线程才会等待工作线程。)
import time
import threading
def bar():
time.sleep(10)
print(‘bar‘)
def foo():
for i in range(20):
print(i)
t = threading.Thread(target=bar,daemon=False)
t.start()
t = threading.Thread(target=foo,daemon=True)
t.start()
print(‘end‘)
这样不会执行bar的,因为主线程的daemon设置的值为True,改为False就好了。
活着让主线程sleep几秒。
import time
import threading
def bar():
time.sleep(10)
print(‘bar‘)
def foo(n):
for i in range(n):
print(i)
t1 = threading.Thread(target=foo,args=(10,),daemon=True)
t1.start()
t2 = threading.Thread(target=foo,args=(20,),daemon=False)
t2.start()
time.sleep(6)
print(‘end‘)
如果non-daemon线程的时候,主线程退出,也不会结束所有的daemon线程,直到所有的non-daemon线程全部结束,如果还有daemon线程,主线程需要退出,会结束所有的daemon线程,退出。
主线程是non-daemon。其他线程靠传参。
决定的是是否需要等待。如果有激活的non-daemon,就需要等待,没有激活的,主线程直接退出。
10)join方法
import time
import threading
def foo(n):
for i in range(n):
print(i)
time.sleep(1)
t1 = threading.Thread(target=foo,args=(10,),daemon=True)
t1.start()
t1.join()
利用join,主线程被迫等待他。把当前线程阻塞住了,x.join就等待谁。保证代码的执行顺序。
使用了join方法后,daemon线程执行完了,主线程才退出了。
Join(timeout= None),是线程的标准方法之一。
一个线程中调用另一个线程的join方法,调用者将被阻塞,直到被调用线程终止。
一个线程可以被join多次。
Timeout参数指定调用者等待多久,没有设置超时的,就会一直等待到调用的线程结束。
调用谁的join方法,就是join谁,就要等睡。
11)daemon线程应用场景
简单来说,本来并没有daemon Thread,这个概念唯一的作用是,当把一个线程设置为daemon,他会随着主线程的退出而退出。
主要应用场景为:
(1)后台任务。发送心跳包,监控。
(2)主线程工作才有用的线程。如主线程中维护着公共的资源,主线程已经清理了,准备退出,而工作线程使用这些资源工作没有意义了,一起退出最合适。
(3)随时可以被终止的线程。
如果主线程退出,想所有其他工作线程一起退出,就使用daemon=True来创建工作线程。
import time
import threading
def bar():
while True:
time.sleep(1)
print(‘bar‘)
def foo():
print(‘t1 daemon = {}‘.format(threading.current_thread().isDaemon()))
t2 = threading.Thread(target=bar)
t2.start()
print(‘t2 daemon = {}‘.format(t2.isDaemon()))
t1 = threading.Thread(target=foo,daemon=True)
t1.start()
time.sleep(3)
print(‘Main end‘)
改造成一直执行的:
import time
import threading
def bar():
while True:
time.sleep(1)
print(‘bar‘)
def foo():
print(‘t1 daemon = {}‘.format(threading.current_thread().isDaemon()))
t2 = threading.Thread(target=bar)
t2.start()
t2.join()
print(‘t2 daemon = {}‘.format(t2.isDaemon()))
t1 = threading.Thread(target=foo,daemon=True)
t1.start()
t1.join()
time.sleep(3)
print(‘Main end‘)
Daemon线程,简化了手动关闭线程的工作。
12)threading.local 类
局部变量的实现:
import threading
import time
def worker():
x = 0
for i in range(10):
time.sleep(0.01)
x += 1
print(threading.current_thread(),x)
for i in range(10):
threading.Thread(target=worker).start()
利用全局变量实现:
import threading
import time
globals_data = threading.local()
def worker():
globals_data.x = 0
for i in range(10):
time.sleep(0.01)
globals_data.x += 1
print(threading.current_thread(),globals_data.x)
for i in range(10):
threading.Thread(target=worker).start()
import threading
X = ‘abc‘
ctx = threading.local()
ctx.x = 123
print(ctx,type(ctx),ctx.x)
def worker():
print(X)
print(ctx)
print(ctx.x) #打印的时候出错,表示x不能跨线程
print(‘working‘)
worker()
print()
threading.Thread(target=worker).start() #另一个线程启动
threading.local类构建了一个大字典,其元素是每一线程实例地址为key和线程对象引用线程单独的字典的映射。
通过threading.local实例就可在不同的线程中,安全的使用线程独有的数据,做到了线程间数据隔离,如同本地变量一样安全。
Local和线程相关的大字典,每次利用的时候利用线程的小字典来顶替local实例的大字典。
不利用的话,全局变量的话直接就是threading.local和本地线程相关的数据。
13)定时器timer延迟执行
Threading.Timer继承自thread,这个类用来另一多久执行一个函数。
Class threading.Timer(interval,function,args=None,kwargs=None)
Start方法执行以后,Timer对象会处于等待状态,等待了interval之后,开始执行function函数的。如果在执行函数之前的等待阶段,使用了cancel方法,就会跳过执行函数结果。
本质上就是一个Thread,只是没有提供name,daemon。
import threading
import logging
import time
def worker():
logging.info(‘in worker‘)
time.sleep(2)
t = threading.Timer(5,worker)
t.start() #启动
print(threading.enumerate())
t.cancel() #取消
time.sleep(1)
print(threading.enumerate())
[<_MainThread(MainThread, started 7512)>, <Timer(Thread-1, started 6644)>]
[<_MainThread(MainThread, started 7512)>]
import threading
import logging
import time
def worker():
logging.info(‘in worker‘)
time.sleep(2)
t = threading.Timer(5,worker)
t.cancel() #取消
t.start() #启动
print(threading.enumerate())
time.sleep(1)
print(threading.enumerate())
[<_MainThread(MainThread, started 7512)>]
[<_MainThread(MainThread, started 7512)>]
二、线程同步
1、概念
线程同步,线程间协同,通过某种技术,让一个线程访问某些数据时候,其他线程不能访问这些数据,直到该线程完成对数据的操作。
不同操作系统实现技术有所不同,有临界区、互斥量、信号量、事件Event。
2、Event
Event事件,是线程间通信机制中最简单的实现,使用一个内部的标记flag,通过flag的True或False的变化来进行操作。
名称 |
含义 |
set() |
标记为True |
clear() |
标记为False |
is_set() |
标记是否为True |
Wait(timeout=None) |
设置等待标记为True的时长,None为无限等待,等到返回True,未等到超时了返回False。 |
课堂练习:老板雇佣了一个工人,让他生产杯子,老板一直等着这个工人,直到上产了十个杯子。
1)利用join
import threading
import time
import logging
def worker(count=10):
cups = []
while len(cups)<count:
logging.info(‘wprking‘)
time.sleep(0.01)
cups.append(1)
print(len(cups))
logging.info(‘I am finished‘)
w = threading.Thread(target=worker)
w.start()
w.join()
2)利用event
import threading
import logging
import time
def boss(event:threading.Event):
logging.info(‘I am boss,waiting‘)
event.wait()
logging.info(‘good job‘)
def worker(event:threading.Event,count=10):
logging.info(‘I am working for u‘)
cups = []
while True:
logging.info(‘makeing‘)
time.sleep(1)
cups.append(1)
if len(cups) >= count:
print(len(cups))
event.set()
break
logging.info(‘finished my job.cups={}‘.format(cups))
event = threading.Event()
w = threading.Thread(target=worker,args=(event,))
b = threading.Thread(target=boss,args=(event,))
w.start()
b.start()
3)wait的应用
import threading
import logging
logging.basicConfig(level=logging.INFO)
def do(event:threading.Event,interval:int):
while not event.wait(interval): #没有置set,所以是False。 不是False的时候就不能进入循环了。
logging.info(‘do sth‘) #没三秒打印一次。 not False执行此语句
e = threading.Event()
threading.Thread(target=do,args=(e,10)).start()
e.wait(12) #整体停留了十秒。
e.set() #重置为True。
print(‘end‘)
4)练习,实现timer。
总结:
使用同一个Event用来做标记。
Event的wait优于time.sleep,更快的切换到其他线程,提高并发效率。
import threading
import time
class MyTimer:
def __init__(self,interval,function,args,kwargs):
self.interval = interval
self.target = function
self.args = args
self.kwargs = kwargs
self.event = threading.Event()
self.thread = threading.Thread(target=self.target,args=self.args,kwargs=self.kwargs)
def start(self):
self.event.wait(self.interval)
if not self.event.is_set(): #如果没有置False,那么就是False,not False为True,执行run语句。
self.run()
def run(self):
self.start()
self.event.set()
def cancel(self):
self.event.set()
Lock锁
1)锁,凡是存在共享资源争抢的地方都可以使用锁。从而保证只有一个使用者可以完全使用这个资源。
lock.acquire 上锁 lock.release 解锁
import threading
import logging
import time
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
cups = []
def worker(count=10):
logging.info(‘i am work‘)
while len(cups) < count:
time.sleep(0.1)
cups.append(1)
logging.info(‘i am finsh.cups={}‘.format(len(cups)))
for _ in range(10):
threading.Thread(target=worker,args=(1000,)).start()
2018-05-26 15:38:25,913 Thread-1 32 i am work
2018-05-26 15:38:25,913 Thread-2 4332 i am work
2018-05-26 15:38:25,913 Thread-3 9992 i am work
2018-05-26 15:38:25,914 Thread-4 8464 i am work
2018-05-26 15:38:25,914 Thread-5 9968 i am work
2018-05-26 15:38:25,915 Thread-6 8712 i am work
2018-05-26 15:38:25,915 Thread-7 4412 i am work
2018-05-26 15:38:25,915 Thread-8 8456 i am work
2018-05-26 15:38:25,915 Thread-9 8316 i am work
2018-05-26 15:38:25,915 Thread-10 9772 i am work
2018-05-26 15:38:35,925 Thread-8 8456 i am finsh.cups=1000
2018-05-26 15:38:36,023 Thread-7 4412 i am finsh.cups=1001
2018-05-26 15:38:36,023 Thread-1 32 i am finsh.cups=1002
2018-05-26 15:38:36,023 Thread-6 8712 i am finsh.cups=1003
2018-05-26 15:38:36,024 Thread-5 9968 i am finsh.cups=1004
2018-05-26 15:38:36,024 Thread-4 8464 i am finsh.cups=1005
2018-05-26 15:38:36,024 Thread-10 9772 i am finsh.cups=1006
2018-05-26 15:38:36,024 Thread-2 4332 i am finsh.cups=1007
2018-05-26 15:38:36,025 Thread-3 9992 i am finsh.cups=1008
2018-05-26 15:38:36,025 Thread-9 8316 i am finsh.cups=1009
运行结果来看,多线程调度,导致了判断失误,多生产了杯子只有用到了锁。
Lock,锁,一旦线程获得锁,其他要获得锁的线程将被阻塞。
名称 |
含义 |
acquire(blocking=True,timeout=-1) |
默认阻塞,阻塞可以设置超时时间,非阻塞时,timeout禁止设置,成果获取锁,返回True,否则返回None |
Release |
释放锁,可以从任何线程调用释放, 已上锁的锁,会被重置到unlocked未上锁的锁上调用,抛出RuntimeError异常。 |
import threading
import logging
import time
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
cups = []
lock = threading.Lock()
def worker(count=10):
logging.info(‘i am work‘)
lock.acquire()
while len(cups) < count:
print(threading.current_thread(),len(cups))
time.sleep(0.000001)
cups.append(1)
logging.info(‘i am finsh.cups={}‘.format(len(cups)))
lock.release()
for _ in range(10):
threading.Thread(target=worker,args=(1000,)).start()
上锁位置不对,由一个线程抢占,并独自占锁并完成任务。
import threading
import logging
import time
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
cups = []
lock = threading.Lock()
def worker(count=10):
logging.info(‘i am work‘)
flag= False
while True:
lock.acquire() #获取锁
if len(cups) >= count:
flag = True
# print(threading.current_thread(),len(cups))
time.sleep(0.000001)
if not flag:
cups.append(1)
print(threading.current_thread(),len(cups))
lock.release() #追加后释放锁
if flag:
break
logging.info(‘i am finsh.cups={}‘.format(len(cups)))
for _ in range(10):
threading.Thread(target=worker,args=(1000,)).start()
锁保证了数据完整性,但是性能下降好多。
If flag:break是为了保证release方法被执行,否则就出现了死锁,得到锁的永远没有释放。
计数器类,可以加可以减。
2)加锁、解锁
一般加锁就需要解锁,但是加锁后解锁前,还要有一些代码执行,就有可能抛出异常,一旦出现异常锁是无法释放的,但是当前线程可能因为这个就异常终止了,这就产生了死锁。
加锁。解锁常用语句:
(1)使用try...finally语句保证锁的释放。
(2)With上下文管理,锁对象支持上下文管理。
import threading
import time
class Counter:
def __init__(self):
self._val = 0
self.__lock = threading.Lock()
@property
def value(self):
return self._val
def inc(self):
try:
self.__lock.acquire()
self._val += 1
finally:
self.__lock.release()
def dec(self):
with self.__lock:
self._val -= 1
def run(c:Counter,count=1000):
for _ in range(10):
for i in range(-50,50):
if i<0:
c.dec()
else:
c.inc()
c = Counter()
c1 = 10
c2 = 10
for i in range(c1):
threading.Thread(target=run,args=(c,c2)).start()
while True:
time.sleep(1)
if threading.active_count() == 1:
print(threading.enumerate())
print(c.value)
break
else:
print(threading.enumerate())
不影响其他线程的切换,但是上锁后其他线程被阻塞了。只能等待。
3)锁的应用场景
适用于访问和修改同一个共享资源的时候,读写同一个资源的时候。
全部是读取同一个共享资源需要锁吗?
因为共享资源是不可变的,每一次读取都是一样的值,所以不用加锁。
使用锁的注意事项:
少用锁必要时用锁,使用了锁,多线程访问被锁的资源时候,就成了串行,要么排队执行,要么争抢执行。
加锁时间越短越好,不需要拍就立即释放锁。
一定要避免死锁。(死锁,打不开,解不开,A有锁,B也锁,占有这把锁的人迟迟不释放锁。没有使用上下文,持有锁的的线程异常退出了)
不使用锁,有了效率,但是结果是错的。
使用了锁,效率低下,但是结果是对的。
4)非阻塞锁使用
import threading
import logging
import time
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker(tasks):
for task in tasks:
time.sleep(0.01)
if task.lock.acquire(False):
logging.info(‘{}{}begin to start‘.format(threading.current_thread(),task.name))
else:
logging.info(‘{}{}is working‘.format(threading.current_thread(),task.name))
class Task:
def __init__(self,name):
self.name = name
self.lock = threading.Lock()
tasks = [Task(‘task-{}‘.format(x))for x in range(10)]
for i in range(5):
threading.Thread(target=worker,name=‘worker-{}‘.format(i),args=(tasks,)).start()
5)可重入锁RLock:
是线程相关的锁
线程A可重复锁,并可以多次成功获取,不会阻塞 ,最后要在线程A中做和acquire次数相同的release。
拿到这把锁的线程可以多次使用。
别的线程拿到的话也是被阻塞的。
一个线程占用锁的时候,其他线程不能拿到,只能的是阻塞。直到当前线程次有的锁全部释放完,其他线程才可以获取。
可重入锁,与线程相关,可在一个线程中获取锁,并可继续在同一线程中不阻塞获取锁,当锁未释放完,其他线程获取锁就会阻塞。直到当前持有锁的线程释放完了锁。
四、Condition
构造方法:condition(lock=None),可以传入一个lock对象或Rlock对象,默认是Rlock。
名称 |
含义 |
Acquire(*args) |
获取锁 |
Wait(self,timeout=None) |
等待超时 |
Notify(n=1) |
唤醒之多指定书目个数的等待的线程,没有等待的线程就没有任何操作 |
Notify_all() |
唤醒所有等待的线程。 |
用于生产者、消费者模型,为了解决生产者消费者速度匹配的问题:
import threading
import logging
import random
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
class Dispatcher:
def __init__(self):
self.data = None
self.event = threading.Event()
def produce(self,total):
for _ in range(total):
data = random.randint(0,100)
logging.info(data)
self.data = data
self.event.wait(1)
self.event.set()
def consume(self):
while not self.event.is_set():
data = self.data
logging.info(‘recieved{}‘.format(data))
self.data = None
self.event.wait(0.5)
d = Dispatcher()
p = threading.Thread(target=d.produce,args=(10,),name=‘producer‘)
c = threading.Thread(target=d.consume,name=‘consume‘)
c.start()
p.start()
消费者采用主动消费,消费者浪费了大量的时间,主动来查看有没有数据。换成通知的机制。
import threading
import logging
import random
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
class Dispatcher:
def __init__(self):
self.data = None
self.event = threading.Event()
self.cond = threading.Condition()
def produce(self,total):
for _ in range(total):
data = random.randint(0,100)
with self.cond:
logging.info(data)
self.data = data
self.cond.notify_all()
self.event.wait(1)
self.event.set()
def consume(self):
while not self.event.is_set():
with self.cond:
self.cond.wait()
logging.info(‘recieved{}‘.format(self.data))
self.data = None
self.event.wait(0.5)
d = Dispatcher()
p = threading.Thread(target=d.produce,args=(10,),name=‘producer‘)
c = threading.Thread(target=d.consume,name=‘consume‘)
c.start()
p.start()
如果是一个生产者,多个消费者呢:
import threading
import logging
import random
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
class Dispatcher:
def __init__(self):
self.data = None
self.event = threading.Event()
self.cond = threading.Condition()
def produce(self,total):
for _ in range(total):
data = random.randint(0,100)
with self.cond:
logging.info(data)
self.data = data
self.cond.notify_all()
self.event.wait(1) #模拟生产速度
self.event.set()
def consume(self):
while not self.event.is_set():
with self.cond:
self.cond.wait() #阻塞等通知
logging.info(‘recieved{}‘.format(self.data))
self.event.wait(0.5) #模拟消费 的速度
d = Dispatcher()
p = threading.Thread(target=d.produce,args=(10,),name=‘producer‘)
for i in range(5):
c = threading.Thread(target=d.consume, name=‘consume{}‘.format(i))
c.start()
p.start()
Self.cond.notify_all()发通知:
修改为self.cond.notify(n=2) 随机通知两个消费者。
Condition总结:
用于生产者消费者模型中,解决生产者,消费者速度匹配的问题。
采用了通知机制,非常有效率。
使用方式:
使用condition,必须先acquire,用完了要release。因为内部实现了锁,默认使用了RLock锁。最好的方式就是使用上下文。
消费者wait,等待通知。
生产者生产好消息,对消费者发出通知,可以使用notify或者notify_all方法。
操作系统中基本单位是进程,进程是独立的王国,操作系统中不可调用线程,线程是轻量级进程,有独立自己栈。资源就是独立的栈。
加载到内存中是进程管理,子系统之一。变成为一个实例,进程ID号。
驱动管理,
协议,
Tcp udp,
http协议。
Linux:
Unix:b语言基础上c语言写的。
Windows:
数据在哪里,计算就在哪里。
五、Barrier
1、栅栏,屏障、为路障、道闸
达到一定的条件,才会打开barrier。
名称 |
含义 |
Barrier(parties,action=None,timeout=None) |
构建barrier对象,指定参与方数目,timeout是wait方法未指定超时的默认值。 |
n_waiting |
当前在屏障中等待的线程数 |
Parties |
各方数,就是需要多少个等待 |
Wait(timeout=None) |
等待通过屏障,返回0到线程数-1的整数,每个线程返回不同,如果wait方法设置了超时,并超时发送,屏障将处于broken状态。 |
import threading
import logging
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker(barrier:threading.Barrier):
logging.info(‘waiting for {}threads‘.format(barrier.n_waiting))
try:
barrier_id = barrier.wait()
logging.info(‘after barrier{}‘.format(barrier_id))
except threading.BrokenBarrierError:
logging.info(‘Broken Barrier‘)
barrier = threading.Barrier(3)
for x in range(3):
threading.Thread(target=worker,name=‘worker-{}‘.format(x),args=(barrier,)).start()
logging.info(‘started‘)
2018-06-11 21:29:45,173 worker-0 8804 waiting for 0threads
2018-06-11 21:29:45,198 worker-1 2668 waiting for 1threads
2018-06-11 21:29:45,199 worker-2 2716 waiting for 2threads
2018-06-11 21:29:45,199 MainThread 10160 started
2018-06-11 21:29:45,199 worker-2 2716 after barrier2
2018-06-11 21:29:45,199 worker-0 8804 after barrier0
2018-06-11 21:29:45,199 worker-1 2668 after barrier1
如果Barrier()的值设置为3,开启5个线程,前三个线程执行后,后面两个线程不够三个线程,所以一直在等待,直到凑到三个barrier才打开。
上面的运行结果,所有线程冲到了barrier前等待,直到到达parties的数目,屏障才打开,所有线程停止等待,继续执行。
再有线程wait,屏障就就绪等待到达参数方数目。
例如就是赛马需要的马匹全部就位,开闸,下一批陆续来到继续等待比赛。。
名称 |
含义 |
Broken |
如果屏障处于打破的状态 返回true。 |
Abort() |
将屏障至于broken状态,等待中的线程或者调用等待方法的线程中都会抛出brokenbarriererror异常,直达reset方法来恢复屏障 |
Reset() |
重置,恢复屏障,重新开始拦截 |
import threading
import logging
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker(barrier:threading.Barrier):
logging.info(‘waiting for {}threads‘.format(barrier.n_waiting))
try:
barrier_id = barrier.wait()
logging.info(‘after barrier{}‘.format(barrier_id))
except threading.BrokenBarrierError:
logging.info(‘Broken Barrier‘)
barrier = threading.Barrier(3)
for x in range(9):
if x == 2:
barrier.abort()
elif x == 6:
barrier.reset()
threading.Event().wait(1)
threading.Thread(target=worker,name=‘worker-{}‘.format(x),args=(barrier,)).start()
logging.info(‘started‘)
2018-06-11 21:42:20,952 worker-0 8460 waiting for 0threads
2018-06-11 21:42:21,953 worker-1 8484 waiting for 1threads
2018-06-11 21:42:21,953 worker-1 8484 Broken Barrier
2018-06-11 21:42:21,954 worker-0 8460 Broken Barrier
2018-06-11 21:42:22,954 worker-2 1500 waiting for 0threads
2018-06-11 21:42:22,955 worker-2 1500 Broken Barrier
2018-06-11 21:42:23,956 worker-3 1200 waiting for 0threads
2018-06-11 21:42:23,956 worker-3 1200 Broken Barrier
2018-06-11 21:42:24,958 worker-4 6652 waiting for 0threads
2018-06-11 21:42:24,958 worker-4 6652 Broken Barrier
2018-06-11 21:42:25,959 worker-5 3212 waiting for 0threads
2018-06-11 21:42:25,959 worker-5 3212 Broken Barrier
2018-06-11 21:42:26,961 worker-6 6344 waiting for 0threads
2018-06-11 21:42:27,962 worker-7 9732 waiting for 1threads
2018-06-11 21:42:28,964 worker-8 6068 waiting for 2threads
2018-06-11 21:42:28,964 worker-8 6068 after barrier2
2018-06-11 21:42:28,965 worker-6 6344 after barrier0
2018-06-11 21:42:28,965 MainThread 9768 started
2018-06-11 21:42:28,965 worker-7 9732 after barrier1
屏障等待了两个,屏障就被break,waiting的线程跑出了brokenbarriererror异常,新wait的线程也是抛出异常,直到屏障恢复,才继续按照parties数目要求继续拦截线程。
非broken状态情况下才可以继续等待。
2、wait方法超时实例
import threading
import logging
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker(barrier:threading.Barrier,i:int):
logging.info(‘waiting for {}threads‘.format(barrier.n_waiting))
try:
# barrier_id = barrier.wait()
# logging.info(‘after barrier{}‘.format(barrier_id))
logging.info(barrier.broken) #是否是broken
if i < 3:
barrier_id = barrier.wait(1)#超时后,屏障broken
else:
if i == 6:
barrier.reset() #恢复屏障
barrier_id = barrier.wait()
logging.info(‘after barrier{}‘.format(barrier_id))
except threading.BrokenBarrierError:
logging.info(‘Broken Barrier.run.‘)
barrier = threading.Barrier(3)
for x in range(9):
# if x == 2:
# barrier.abort()
# elif x == 6:
# barrier.reset()
threading.Event().wait(2)
threading.Thread(target=worker,name=‘worker-{}‘.format(x),args=(barrier,x)).start()
logging.info(‘started‘)
2018-06-11 21:53:47,966 worker-0 8656 waiting for 0threads
2018-06-11 21:53:47,967 worker-0 8656 False
2018-06-11 21:53:48,967 worker-0 8656 Broken Barrier.run.
2018-06-11 21:53:49,968 worker-1 168 waiting for 0threads
2018-06-11 21:53:49,968 worker-1 168 True
2018-06-11 21:53:49,969 worker-1 168 Broken Barrier.run.
2018-06-11 21:53:51,969 worker-2 6448 waiting for 0threads
2018-06-11 21:53:51,970 worker-2 6448 True
2018-06-11 21:53:51,970 worker-2 6448 Broken Barrier.run.
2018-06-11 21:53:53,970 worker-3 6192 waiting for 0threads
2018-06-11 21:53:53,970 worker-3 6192 True
2018-06-11 21:53:53,971 worker-3 6192 Broken Barrier.run.
2018-06-11 21:53:55,972 worker-4 6380 waiting for 0threads
2018-06-11 21:53:55,972 worker-4 6380 True
2018-06-11 21:53:55,973 worker-4 6380 Broken Barrier.run.
2018-06-11 21:53:57,973 worker-5 3228 waiting for 0threads
2018-06-11 21:53:57,973 worker-5 3228 True
2018-06-11 21:53:57,974 worker-5 3228 Broken Barrier.run.
2018-06-11 21:53:59,975 worker-6 3924 waiting for 0threads
2018-06-11 21:53:59,975 worker-6 3924 True
2018-06-11 21:54:01,975 worker-7 6636 waiting for 1threads
2018-06-11 21:54:01,975 worker-7 6636 False
2018-06-11 21:54:03,976 worker-8 9684 waiting for 2threads
2018-06-11 21:54:03,976 worker-8 9684 False
2018-06-11 21:54:03,977 worker-8 9684 after barrier2
2018-06-11 21:54:03,977 worker-7 6636 after barrier1
2018-06-11 21:54:03,977 MainThread 10036 started
2018-06-11 21:54:03,978 worker-6 3924 after barrier0
3、Barrier应用
并发初始化:
所有线程都必须初始化完成后,才能继续工作。运行前加载数据、检查,如果这些工作没完成,就开始运行,将不能正常工作。
10个线程做10种准备工作,每一个线程负责一种工作,只有这10个线程都完成后,才能继续工作,先完成的要等待后完成的线程。
启动一个程序,需要先加载磁盘文件、缓存预热、初始化连接池等工作,这些工作可以齐头并进,不过只有都满足了,程序才会继续向后执行,假设数据库连接失败,则初始化工作失败,就要abort,所有线程收到异常退出。
4、semaphore信号量
和lock很像,信号量对象内部维护一个倒计数器,每一次acquire都会减一,当acquire方法发现技术为0就阻塞请求的线程,直到其他线程对信号量release后,计数器大于0,恢复阻塞的线程。
名称 |
含义 |
Semaphore(value=1) |
构造方法,value小于0,抛出valueerror异常 |
Acquire(blocking=True,timeout=None) |
获取信号量,计数器减一,获取成功返回true |
Release() |
释放信号量,计数器加1 |
计数器永远不会低于0,因为acquire的时候,发现是0,都会被阻塞。
用with语法。
Boundedsemaphore。
import threading
import logging
import time
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker(s:threading.Semaphore):
logging.info(‘in sub thread‘)
logging.info(s.acquire())
logging.info(‘sub thread over‘)
s = threading.Semaphore(3)
logging.info(s.acquire())
print(s._value)
logging.info(s.acquire())
print(s._value)
logging.info(s.acquire())
print(s._value)
threading.Thread(target=worker,args=(s,)).start()
time.sleep(2)
logging.info(s.acquire(False))
logging.info(s.acquire(timeout=3))
logging.info(‘relesed‘)
s.release()
2018-06-11 22:36:17,646 MainThread 9340 True
2
2018-06-11 22:36:17,647 MainThread 9340 True
1
2018-06-11 22:36:17,647 MainThread 9340 True
0
2018-06-11 22:36:17,647 Thread-1 8124 in sub thread
2018-06-11 22:36:19,647 MainThread 9340 False
2018-06-11 22:36:22,648 MainThread 9340 False
2018-06-11 22:36:22,648 MainThread 9340 relesed
2018-06-11 22:36:22,648 Thread-1 8124 True
2018-06-11 22:36:22,649 Thread-1 8124 sub thread over
5、连接池
连接池,因为资源有限,且开启一个连接成本较高,所以利用连接池。
一个简单的连接池,连接池应该有容量(总数),有一个工厂方法可以获取连接,能够把不用的连接返回。供其他调用者使用。
class Conn:
def __init__(self,name):
self.name = name
class Pool:
def __init__(self,count:int):
self.count = count
#池中是连接对象的列表
self.pool = [self._connect(‘conn-{}‘.format(x))for x in range(self.count)]
def _connect(self,conn_name):
#创建连接的方法,返回一个名称
return Conn(conn_name)
def get_conn(self):
#从池中拿走一个连接
if len(self.pool) > 0:
return self.pool.pop()
def return_conn(self,conn:Conn):
#向池中添加一个连接
self.pool.append(conn)
上面的例子只是一个简单的功能实现。Get_conn()方法在多线程的时候也会有线程安全问题。
import threading
import logging
import random
FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘
logging.basicConfig(format=FORMAT,level=logging.INFO)
class Conn:
def __init__(self,name):
self.name = name
def __repr__(self):
return self.name
class Pool:
def __init__(self,count:int):
self.count = count
self.pool = [self._connect(‘conn-{}‘.format(x))for x in range(count)]
self.semaphore = threading.Semaphore(count)
def _connect(self,conn_name):
return Conn(conn_name)
def get_conn(self):
print(‘----‘)
self.semaphore.acquire()
print(‘======‘)
conn = self.pool.pop()
return conn
def return_conn(self,conn:Conn):
self.pool.append(conn)
self.semaphore.release()
pool = Pool(3)
def worker(pool:Pool):
conn = pool.get_conn()
logging.info(conn)
threading.Event().wait(random.randint(1,2))
pool.return_conn(conn)
for i in range(6):
threading.Thread(target=worker,name=‘worker{}‘.format(i),args=(pool,)).start()
----
2018-06-12 20:13:21,119 worker0 8392 conn-2
======
----
======
2018-06-12 20:13:21,120 worker1 8240 conn-1
----
======
----
2018-06-12 20:13:21,120 worker2 3216 conn-0
----
----
======
2018-06-12 20:13:22,120 worker3 5700 conn-0
2018-06-12 20:13:23,119 worker4 7448 conn-2
======
2018-06-12 20:13:23,120 worker5 2556 conn-1
======
上例中,使用信号量解决资源有限的问题,如果池中有资源,请求者获取资源时候信号量减1,拿走资源,当请求超过资源数,请求者只能等待,当使用者用完归还资源后信号量加1,等待线程就可以被唤醒拿走资源。
容器,预加载,懒加载。
6、问题
Self.conns.append(conn)是否需要加锁。
1)逻辑分析处理
还没有使用信号量,就release,。
import logging
import threading
sema = threading.Semaphore(3)
logging.warning(sema.__dict__)
for i in range(3):
sema.acquire()
logging.warning(‘~~~~~~~‘)
logging.warning(sema.__dict__)
for i in range(4):
sema.release()
logging.warning(sema.__dict__)
for i in range(3):
sema.acquire()
logging.warning(‘~~~~‘)
logging.warning(sema.__dict__)
sema.acquire()
logging.warning(‘~~~~~‘)
logging.warning(sema.__dict__)
WARNING:root:{‘_cond‘: <Condition(<unlocked _thread.lock object at 0x000000C13D6C0B98>, 0)>, ‘_value‘: 3}
WARNING:root:~~~~~~~
WARNING:root:{‘_cond‘: <Condition(<unlocked _thread.lock object at 0x000000C13D6C0B98>, 0)>, ‘_value‘: 0}
WARNING:root:{‘_cond‘: <Condition(<unlocked _thread.lock object at 0x000000C13D6C0B98>, 0)>, ‘_value‘: 4}
WARNING:root:~~~~
WARNING:root:{‘_cond‘: <Condition(<unlocked _thread.lock object at 0x000000C13D6C0B98>, 0)>, ‘_value‘: 1}
WARNING:root:~~~~~
WARNING:root:{‘_cond‘: <Condition(<unlocked _thread.lock object at 0x000000C13D6C0B98>, 0)>, ‘_value‘: 0}
计数器超过了4,超过了设置的最大值,需要解决问题:
Boundedsemaphore类
有界的信号量,不允许使用release超出初始值的范围,否则就会抛出valueerror异常。
保证了多归还连接抛出异常。
2)如果使用了信号量,还没用完。
计数器还差一个就满了,有三个线程ABC都执行了第一句,都没有来得及release,这个时候轮到 A release,正常的release,然后轮到线程C先release,一定会出现问题,超届,会抛出异常,信号量可以保证,一定不能多归还。
3)许多线程用完了信号量
没有信号量的线程都被阻塞,没有线程和归还的线程争抢,当append后才release,这个时候才能等待的线程被唤醒,才能pop,没有获取信号量的不能pop,这样才是安全的。
7、信号量和锁
锁,只允许同一个时间一个线程独占资源,他是特殊的信号量,即信号量初始值为1.
信号量,可以多个线程访问共享资源,但这个共享资源属相有限,锁,可以看做是特殊的信号量。
Event lock sem 三个必须要会用。
8、数据结构和gill
Queue是线程安全的,里面用到了锁,还有condition,用的是lock。
Queue是标准库模块,提供FIFO的queue,lifo的队列,有限队列。
Queue是线程安全的,适用于线程间的安全交换数据,内部使用了lock和condition。
原子操作,一堆操作中要么全部做完,要么全部做不完。
Guarantee 保证。
严格要注意的事项:
9、gil全局解释器锁
CPython在解释器进程中大锁,叫做gill全局解释器锁。大锁解决进程内的所有线程的问题,在CPU上只有一个线程被调度使用。
同一个时间内同一个进程内只有一个线程在工作,在执行字节码,甚至在多核的CPU的情况下,也是如此。
cPython中:
IO密集型:由于线程阻塞,就会调度其他线程。
CPU密集型:不访问网络,当前线程可能会连续的获得gill,导致其他线程几乎无法使用CPU。
在cPython中由于gill存在,IO密集型,使用多线程较为合算,CPU密集型,使用多进程,要绕开gill。
新版cPython正在努力优化gill的问题,但是不是移除的问题,
Python中绝大多数内置数据结构的读、写操作都是原子操作。
由于gill的存在,Python的内置数据类型在多线程编程的时候变成了安全的,但是实际上本身不是线程和安全类型。
移除gill,会降低cPython单线程的执行效率。
本身不安全,有全局解释器锁gill,都是由线程操作的,线程安全的。
以上是关于Python中并发多线程等的主要内容,如果未能解决你的问题,请参考以下文章