线程:
优点:共享内存,IO操作时,创造并发操作
缺点:枪战资源
线程不是越多越好,具体案例具体分析,请求上下文切换耗时
IO密集型适用于线程,IO操作打开文件网络通讯类,不需要占用CPU,只是由CPU调度一下(不占用CPU)
自定义进程和线程:注意python解释器自带了主进程和主线程,比如在代码文件里没有定义线程和进程,程序也能运行就是靠的解释器自带主进程的主线程执行的
自定义进程:
由主进程创建,子进程
自定义线程:
由主线程创建,子线程
GIL全局解释器锁:
GIL全局解释器锁在进程入口,控制着进程数量与CPU的相应
threading线程模块
线程是应用程序中工作的最小单元
threading 模块建立在 _thread 模块之上。thread 模块以低级、原始的方式来处理和控制线程,而 threading 模块通过对 thread 进行二次封装,提供了更方便的 api 来处理线程。
hread()创建线程对象【有参】
使用方法:赋值变量 = 模块名称.Thread(target=事件函数,args=元祖类型事件函数的实际参数) 如函数多个参数,元祖里就是多个元素
格式:t = threading.Thread(target=show, args=(i,))
currentThread()获取当前线程【无参】
使用方法:自定义变量 = threading模块名称.currentThread()
格式:current_thread = threading.currentThread()
start()激活线程【无参】
使用方法:thread对象变量.start()
格式:t.start()
#!/usr/bin/env python
# -*- coding:utf8 -*-
import threading #导入线程模块
import time #导入时间模块
def show(arg): #定义函数
time.sleep(3) #睡眠3秒
print('线程'+str(arg)) #打印线程加循环次数
for i in range(10): #定义一个10次循环
t = threading.Thread(target=show, args=(i,)) #用threading模块的Thread类来创建子线程对象
t.start() #激活子线程
print("默认主线程等待子线程完成任务后,主线程停止")
# 输出
# 默认主线程等待子线程完成任务后,主线程停止
# 线程0
# 线程5
# 线程8
# 线程3
# 线程6
# 线程4
# 线程1
# 线程7
# 线程2
# 线程9
上述代码创建了10个“前台”线程,然后控制器就交给了CPU,CPU根据指定算法进行调度,分片执行指令。
from threading import Thread
import time
class Sayhi(Thread):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
time.sleep(2)
print('%s say hello' % self.name) if __name__ == '__main__':
t = Sayhi('egon')
t.start()
print('主线程')
在一个进程下开启多个线程与在一个进程下开启多个子进程的区别
from threading import Thread
from multiprocessing import Process
import os def work():
print('hello') if __name__ == '__main__':
#在主进程下开启线程
t=Thread(target=work)
t.start()
print('主线程/主进程')
'''
打印结果:
hello
主线程/主进程
''' #在主进程下开启子进程
t=Process(target=work)
t.start()
print('主线程/主进程')
'''
打印结果:
主线程/主进程
hello
'''
线程的join与setdaemon
与进程的方法都是类似的,其实是multiprocessing模仿threading的接口
join与setdaemon
join()逐个执行每个线程,等待一个线程执行完毕后继续往下执行,该方法使得多线程变得无意义【有参可选】
有参可选,参数为等待时间,秒为单位,如t.join(1) 就是一个线程不在是等待它执行完,而是只等待它1秒后继续下一个线程
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name) if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',))
t.setDaemon(True) #等待子线程完成
t.start()
t.join()
print('主线程')
print(t.is_alive())
Thread实例对象的方法
# isAlive(): 返回线程是否活动的。
isAlive()判断线程是否为激活状态返回布尔值【无参】
使用方法:thread对象变量.isAlive()
格式:t.isAlive()
# getName(): 返回线程名。
getName()获取线程的名称【无参】
使用方法:thread对象变量.getName()
格式:t.getName()
# setName(): 设置线程名。
setName()设置线程的名称【有参】
使用方法:thread对象变量.setName("要设置的线程名称")
格式:t.setName("jhf")
name获取或设置线程的名称【无参】
使用方法:thread对象变量.name
格式:t.name
isDaemon()判断是否为守护线程,也就是主线程是否等待子线程执行完成后,才停止主线程,返回布尔值【无参】
使用方法:thread对象变量.isDaemon()
格式:t.isDaemon()
threading模块提供的一些方法:
# threading.currentThread(): 返回当前的线程变量。
# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
# threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。
线程锁threading.RLock和threading.Lock
我们使用线程对数据进行操作的时候,如果多个线程同时修改某个数据,可能会出现不可预料的结果,为了保证数据的准确性,引入了锁的概念。
没有线程锁的情况列如:一个全局变量值为50,创建10条线程让每条线程累计减一,输出的结果是10个40,原因是10条线程同时减一就减去了10,所以打印出来就是10个40了
未使用锁:
#!/usr/bin/env python
# -*- coding:utf8 -*-
import threading #导入线程模块
import time #导入时间模块
globals_num = 50 #设置一个变量
def Func(a): #定义一个函数
global globals_num #将变量转换成全局变量,函数里可以调用
globals_num -= 1 #全局变量减1
time.sleep(1) #睡眠1秒
print(globals_num,a) #打印全局变量减少后的结果,和函数传进来的值
for i in range(10): #创建一个10次循环
t = threading.Thread(target=Func,args=(i,)) #创建线程对象
t.start() #激活线程
# 输出 没有线程锁,线程之间抢占了数据资源
# 40 5
# 40 3
# 40 6
# 40 4
# 40 0
# 40 2
# 40 1
# 40 9
# 40 8
# 40 7
根据上列情况可以看出,没有线程锁,线程之间抢占了数据资源
线程锁就是将线程锁定,一个线程执行完毕后释放锁后在执行第二个线程 RLock()定义线程锁对象
使用方法:定义对象变量 = threading模块名称.RLock()
格式:lock = threading.RLock()
acquire()获得锁,将线程锁定,一个线程执行完毕释放锁后在执行第二个线程
使用方法:线程锁对象变量.acquire()
格式:lock.acquire()
release()释放线程锁
使用方法:线程锁对象变量.release()
格式:lock.release()
使用锁:
#!/usr/bin/env python
# -*- coding:utf8 -*-
import threading #导入线程模块
import time #导入时间模块
globals_num = 50 #设置一个变量
lock = threading.RLock()
def Func(a): #定义一个函数 lock.acquire() # 获得锁,将线程锁定,一个线程执行完毕后在执行第二个线程 global globals_num #将变量转换成全局变量,函数里可以调用
globals_num -= 1 #全局变量减1
time.sleep(1) #睡眠1秒
print(globals_num,a) #打印全局变量减少后的结果,和函数传进来的值 lock.release() # 释放锁 for i in range(10): #创建一个10次循环
t = threading.Thread(target=Func,args=(i,)) #创建线程对象
t.start() #激活线程
# 输出 将线程锁定,一个线程执行完毕后在执行第二个线程
# 49 0
# 48 1
# 47 2
# 46 3
# 45 4
# 44 5
# 43 6
# 42 7
# 41 8
# 40 9
threading.RLock和threading.Lock 的区别
RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock,那么acquire和release必须成对出现,即调用了n次acquire,必须调用n次的release才能真正释放所占用的琐。
threading.Event事件对象
Event()创建标识事件对象,全局定义了一个“Flag”,如果“Flag”值为 False,那么当程序执行 event.wait 方法时就会阻塞,如果“Flag”值为True,那么event.wait 方法时便不再阻塞
python线程的事件用于主线程控制其他线程的执行,事件主要提供了三个方法 set、wait、clear。
事件处理的机制:全局定义了一个“Flag”,如果“Flag”值为 False,那么当程序执行 event.wait 方法时就会阻塞,如果“Flag”值为True,那么event.wait 方法时便不再阻塞。
当线程执行的时候,如果flag为False,则线程会阻塞,当flag为True的时候,线程不会阻塞。它提供了本地和远程的并发性。
Event事件对象的方法有
wait([timeout]) : 堵塞线程,直到Event对象内部标识位被设为True或超时(如果提供了参数timeout)。
set() :将标识位设为Ture
clear() : 将标识位设为False。
isSet() :判断标识位是否为Ture。
#!/usr/bin/env python
# -*- coding:utf8 -*-
import threading
def do(event):
print('start')
event.wait() #堵塞线程,直到Event对象内部标识位被设为True或超时(如果提供了参数timeout)
print('execute')
event_obj = threading.Event() #创建标识事件对象
for i in range(10):
t = threading.Thread(target=do, args=(event_obj,)) #创建线程对象
t.start() #激活线程
event_obj.clear() #将标识设置为False
inp = input('input:')
if inp == 'true':
event_obj.set() #将标识设置为True
# 输出
# start
# start
# start
# start
# start
# start
# start
# start
# start
# input:true
# execute
# execute
# execute
# execute
# execute
# execute
# execute
# execute
# execute
# execute
threading.BoundedSemaphore信号对象
是同时允许一定数量的线程更改数据 ,比如厕所有3个坑,那最多只允许3个人上厕所,后面的人只能等里面有人出来了才能再进去。
BoundedSemaphore()创建信号对象【有参】
使用方法:定义变量.threading.BoundedSemaphore(最大允许线程数)
格式:semaphore = threading.BoundedSemaphore(5)
BoundedSemaphore信号对象的方法有
acquire()获取信号
release()释放信号
from threading import Thread,Semaphore
import time
def work(id):
with sem:
time.sleep(2)
print('%s say hello' %id) if __name__ == '__main__':
sem=Semaphore(5) #最多以5个线程同时运行
for i in range(20):
t=Thread(target=work,args=(i,))
t.start()
queue模块
Queue 就是对队列,它是线程安全的
举例来说,我们去肯德基吃饭。厨房是给我们做饭的地方,前台负责把厨房做好的饭卖给顾客,顾客则去前台排队领取做好的饭。这里的前台就相当于我们的队列。
这个模型也叫生产者-消费者模型。
Queue()创建队列对象【有参】
使用方法:定义变量 = queue.Queue(对列长度数) 0表示长度无限制
格式:message = queue.Queue(10)
Queue对象方法有:
join()等到队列为空的时候,在执行别的操作【无参】
qsize()返回队列的大小(不可靠),因为获取后有可能有新数据加入【无参】
empty()清空队列里的所有数据
full()检查队列是否为满,当队列满的时候,返回True,否则返回False(不可靠),因为获取后有可能有新数据加入【无参】
put(放入对列的数据必选, block=True, timeout=None) 向队列里放入数据(生产)【有参】
将数据放入对列尾部(生产),数据必须存在,可以参数block默认为True,表示当队列满时,会等待队列给出可用位置,为False时为非阻塞,此时如果队列已满,会引发queue.Full 异常。
可选参数timeout,表示 会阻塞设置的时间,过后,如果队列无法给出放入item的位置,则引发 queue.Full 异常
get(block=True, timeout=None)移除并返回队列头部的一个值(消费)【有参】
可选参数block默认为True,表示获取值的时候,如果队列为空,则阻塞,为False时,不阻塞,若此时队列为空,则引发 queue.Empty异常。
可选参数timeout,表示会阻塞设置的时候,过后,如果队列为空,则引发Empty异常。
put_nowait(放入对列的数据必选)向队列里放入数据(生产)【有参】,如果队列满时不阻塞,不等待队列给出可用位置,引发 queue.Full 异常
get_nowait()移除并返回队列头部的一个值(消费)【无参】,如果队列空时不阻塞,引发 queue.Full 异常
class queue.Queue(maxsize=0) #先进先出
import queue q=queue.Queue()
q.put('first')
q.put('second')
q.put('third') print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''
class queue.
LifoQueue
(maxsize=0) #last in fisrt out
import queue q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third') print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''
class queue.
PriorityQueue
(maxsize=0) #存储数据时可设置优先级的队列
import queue q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c')) print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''
定时器,指定n秒后执行某操作
from threading import Timer def hello():
print("hello, world") t = Timer(1, hello)
t.start() # after 1 seconds, "hello, world" will be printed