进程和线程
- 进程:正在执行的程序。
在实现了进程的操作系统中。 - 线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。一个程序执行实例就是一个进程。
- 现代操作系统提出进程的概念,每一个进程都认为自己是计算机硬件资源,进程就是独立的王国,进程间不可以随便的共享资源。
- 线程就是省份,同一个进程内的线程可以共享进程的资源,每一个线程拥有自己独立的堆栈。
线程的状态
状态 | 含义 |
---|---|
就绪 | 线程能够运行,但是在等待被调度,可能线程刚刚创建启动,或刚刚从阻塞中恢复,或者被其他线程抢占 |
运行 | 线程正在运行 |
阻塞 | 线程等待外部事件发生而无法运行 |
终止 | 线程完成,或退出,或被取消 |
Python中的进程和线程
进程会启动一个解释器进程,线程共享一个解释器进程。
Python的线程开发
Python的线程开发使用标准库threading
进程靠线程执行代码,至少有一个主线程,其他线程是工作线程。
主线程是第一个启动的线程。
Thread类
#签名
def __init__(self,group=None,target=None,name=None,args=().kwargs=None,*,daemon=None)
参数名 | 含义 |
---|---|
target | 线程调用的对象,就是目标函数 |
name | 为线程起个名字 |
args | 为目标函数传递实参,元组 |
kwargs | 为目标函数关键字传参,字典 |
线程的启动
import threading
def worker():
print('work')
t=threading.Thread(target=worker,name='work')
t.start()
通过threading.Thread创建一个线程对象,target是目标函数,可以使用name为线程指定名称。
但是线程没有启动,需要调用start方法。
线程之所以执行函数,因为线程中就是要执行的代码。
线程退出
Python中没有提供线程退出的方法,线程在下面情况时退出
- 线程函数内语句执行完毕
- 线程函数中抛出未处理的异常
import threading
def worker():
raise Exception('1')
while True:
print('work')
t=threading.Thread(target=worker,name='work')
t.start()
Python的线程没有优先级,没有线程组的概念,也不能比销毁、停止、挂起,也没有恢复、中断
线程的传参
import threading
import time
def add(x,y):
print(threading.current_thread().ident)
print(threading.current_thread().name)
print(x+y)
return x+y
t=threading.Thread(target=add,name='add',args=(1,2))
t.start()
threading的属性和方法
名称 | 含义 |
---|---|
current_thread() | 返回当前线程对象 |
main_thread() | 返回主线程对象 |
active_count() | 当前处于alive状态的线程个数 |
enumerate() | 返回所有活着的线程的列表,不包括已经终止的线程和未开始的线程 |
get_ident() | 返回当前线程的ID,非0整数 |
import threading
import time
def show():
print(threading.current_thread())
print(threading.main_thread())
print(threading.active_count())
print(threading.enumerate())
print(threading.get_ident())
def work():
# show()
for i in range(5):
time.sleep(1)
print('work')
t=threading.Thread(target=work,name='work')
t.start()
show()
##### Thread实例的属性和方法
名称 | 含义 |
---|---|
name | 只是一个名字,一个表示,名字可以重名,getName(),setName()获取、设置这个名词 |
ident | 线程ID,是非0整数。线程启动才有ID,否则为None,线程退出,ID依旧可以访问 |
is_alive() | 返回线程是否活着 |
import threading
import time
def work():
for i in range(5):
time.sleep(2)
print('working')
print('finish')
t=threading.Thread(target=work,name='work')
print(t.name,t.ident)
time.sleep(1)
t.start()
print('++++++++++')
while True:
time.sleep(1)
print('alive',t.is_alive())
print('ID',t.ident)
print('name',t.name)
break
start和run
名称 | 含义 |
---|---|
start() | 启动线程,每一个线程必须且只能执行该方法一次 |
run() | 运行线程函数 |
- start
import threading
import time
def work():
for i in range(5):
time.sleep(1)
print('work')
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t=Mythread(target=work,name='work')
t.start()
- run
import threading
import time
def work():
for i in range(5):
time.sleep(1)
print('work')
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t=Mythread(target=work,name='work')
# t.start()
t.run()
start()方法会调用run()方法,而run()方法可以运行函数。
- start和run的区别
import threading
import time
def work():
print(threading.enumerate())
for i in range(5):
time.sleep(1)
print('work')
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t=Mythread(target=work,name='work')
# t.start()
t.run()
import threading
import time
def work():
print(threading.enumerate())
for i in range(5):
time.sleep(1)
print('work')
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t=Mythread(target=work,name='work')
t.start()
# t.run()
使用start方法启动线程,启动了一个新的线程,但是使用run方法,并没有启动新的线程,就是在主线程中调用了一个普通的函数而已。
多线程
多个线程,一个进程如果有多个线程进行,就是多线程,实现一种并发。
import threading
import time
def work():
t=threading.current_thread()
for i in range(5):
time.sleep(1)
print('work',t.name,t.ident)
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t1=Mythread(target=work,name='work1')
t1.start()
t2=Mythread(target=work,name='work2')
t2.start()
可以看到work1和work2交替执行。
import threading
import time
def work():
t=threading.current_thread()
for i in range(5):
time.sleep(1)
print('work',t.name,t.ident)
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t1=Mythread(target=work,name='work1')
# t1.start()
t1.run()
t2=Mythread(target=work,name='work2')
# t2.start()
t2.run()
没有新的线程,就是函数普通调用,执行完t1.run(),执行t2.run(),这里不是多线程。
当使用start方法启动线程后,进程内有多个活动的线程并行的工作,就是多线程。
一个进程中至少有一个线程,作为程序的入口,这个线程就是主线程。
一个进程至少一个主线程
其他线程称为工作线程。
线程安全
import threading
import time
def work():
t=threading.current_thread()
for i in range(5):
time.sleep(1)
print('work',t.name,t.ident)
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t1=Mythread(target=work,name='work1')
t1.start()
t2=Mythread(target=work,name='work2')
t2.start()
代码中有空行和被打印在一起的。
- 线程安全:线程执行一段代码,不会产生不确定的结果,那这段代码就是线程安全的
为了出现线程不安全:使用logging
标准库里面的logging模块,日志处理模块,线程安全的,生成环境代码都使用logging
import threading
import time
import logging
def work():
t=threading.current_thread()
for i in range(5):
time.sleep(1)
logging.warning('work')
logging.warning(t.name)
logging.warning(t.ident)
logging.warning('~~~~~~~~~~~~~~~~~~~~~~~~~')
print('finish')
class Mythread(threading.Thread):
def start(self):
print('start____________')
super().start()
def run(self):
print('run______________')
super().run()
t1=Mythread(target=work,name='work1')
t1.start()
# t1.run()
t2=Mythread(target=work,name='work2')
t2.start()
# t2.run()
daemon线程和non-daemon线程
Python中,构建线程的时候,可以设置daemon属性,这个属性必须在start方法前设置好
#源码Thread的__init__方法中
if daemon is not None:
self._daemonic=daemon #用户设定的bool值
else:
self._daemonic=current_thread()
线程daemon属性,如果设定就是用户的设置,否则就取当前线程的daemon值。
主线程是non-daemon线程,即daemon=False
import time
import threading
def foo():
time.sleep(2)
for i in range(10):
print(i)
t=threading.Thread(target=foo,daemon=False)
t.start()
print('final')
from threading import Thread
class M(Thread):
def __init__(self):
Thread.__init__(self,name='M',daemon=False)
import time
import threading
def foo():
time.sleep(2)
for i in range(10):
print(i)
t=threading.Thread(target=foo,daemon=True)
t.start()
print('final')
daemon为False,主线程会等待线程t,直到线程t结束。
daemon为True时,主线程并不会等待线程t。
名称 | 含义 |
---|---|
daemon属性 | 表示线程是否是daemon线程,这个值必须在start()之前设置,否则引发RuntimeError异常 |
isDaemon() | 是否是daemon线程 |
setDaemon | 设置为daemon线程,必须在start方法之前设置 |
import time
import threading
def work(name,ti):
time.sleep(ti)
print(threading.current_thread().daemon)
print(name)
t1=threading.Thread(target=work,args=('t1',5),daemon=False)
t1.start()
t2=threading.Thread(target=work,args=('t2',10),daemon=False)
t2.start()
print('final____________')
上例子说明如果除了主线程之外还有non-daemon线程的时候,主线程退出时,也不会杀掉所有daemon线程,直到所有的non-daemon线程全部结束,如果还有daemon线程,主线程需要退出(主线程退出也可以理解为最后一个non-daemon线程也要退出了),会结束所有daemon线程,程序退出。
- 总结
- 线程具有一个daemon属性,可以手动设置为True或False,也可以不设置,则取当前线程的daemon来设置它。
- 主线程是non-daemon线程,即daemon=False
- 从主线程创建的所有线程都不设置daemon属性,则默认都是daemon=False,也就是non-daemon线程。
- Python程序在没有或者的non-daemon线程运行时,程序退出,也就是除主线程外剩下的只能都是daemon线程,主程序才能退出,否则主线程只能等待。
join方法
import time
import threading
def work(name,ti):
time.sleep(ti)
print(threading.current_thread().daemon)
print(name)
t1=threading.Thread(target=work,args=('t1',10),daemon=True)
t1.start()
t1.join()
print('final____________')
使用了join方法后,daemon线程执行完了,主线程才能退出
import time
import threading
def work(name,ti):
time.sleep(ti)
print(threading.current_thread().daemon)
print(name)
t1=threading.Thread(target=work,args=('t1',10),daemon=True)
t1.start()
t1.join(2)
print('final____________')
t1.join(2)
print('final____________')
join(timeout=None),是线程的标准方法之一。
一个线程中调用另一个线程的join方法,调用者将被阻塞,直到被调用线程终止,一个线程可以被join多次。
timeout参数指定调用者等待多久,没有设置超时,就一直等到被调用线程结束。
调用谁的join方法,就是join谁,就要等谁。
daemon线程应用场景
简单来说就是,本来没有daemon thread,为了简化程序员的工作,让他们不用去记录和管理那些后台线程,创造了一个daemon thread的概念,这个概念唯一的作用就是,当你把一个线程设置为daemon,它可以随主线程的退出而退出。
主要应用场景:
1、后台任务
2、主线程任务才有用的线程。
3、随时可以被终结的线程。
- 如果主线程退出,想所有其它工作线程一起退出,就使用daemon=True来创建工作线程。
- 如果在non-daemon线程A中,对另一个daemon线程B使用了join方法,这个线程B设置成daemon就没有什么意义了,因为non-daemon线程A总是要等待B。
- 如果在non-daemon线程C中,对另一个daemon线程D使用了join方法,只能说明C要等待D,主线程退出,C和D不管是否结束,都要结束掉。
import time
import threading
def work1(name):
while True :
time.sleep(2)
print(threading.current_thread().isDaemon())
def work2(name):
current=threading.current_thread()
print(name,current.isDaemon())
t2=threading.Thread(target=work1,args=('t2',))
t2.start()
t1=threading.Thread(target=work2,args=('t1',),daemon=True)
t1.start()
time.sleep(3)
print('over')
上例,主要主线程要退出,2个工作线程都结束。
可以使用Join,让线程结束不了。
import time
import threading
def work1(name):
while True :
time.sleep(2)
print(threading.current_thread().isDaemon())
def work2(name):
current=threading.current_thread()
print(name,current.isDaemon())
t2=threading.Thread(target=work1,args=('t2',))
t2.start()
t1=threading.Thread(target=work2,args=('t1',),daemon=True)
t1.start()
t1.join()
time.sleep(4)
print('over')
threading.local类
import time
import threading
import logging
def foo():
x=0
for i in range(10):
time.sleep(0.1)
x+=1
logging.warning('{}{}'.format(threading.current_thread(),x))
for i in range(10):
threading.Thread(target=foo).start()
上例使用多线程,每个线程完成不同的计算任务,x是局部变量,可以看出每一个线程的x是独立的,互不干扰。
import time
import threading
import logging
class A:
def __init__(self):
self.x=0
#全局对象
globals_data=A()
def work():
globals_data.x=0
for i in range(10):
time.sleep(0.1)
globals_data.x+=1
logging.warning("{}{}".format(threading.current_thread(),globals_data.x))
for i in range(10):
threading.Thread(target=work).start()
上例使用了全局对象,但是线程之间互相干扰,导致了超出预期的结果。
Python提供了threading.local类,将实例化得到一个全局对象,但是不同线程使用这个对象存储的数据其他线程看不见。
import time
import threading
import logging
#全局对象
globals_data=threading.local()
def work():
globals_data.x=0
for i in range(10):
time.sleep(0.1)
globals_data.x+=1
logging.warning("{}{}".format(threading.current_thread(),globals_data.x))
for i in range(10):
threading.Thread(target=work).start()
import threading
x='abc'
global_data=threading.local()
global_data.x=100
print(global_data,type(global_data),global_data.x)
def woek():
print(x)
print(global_data)
print(global_data.x)
print('work')
woek()
print('~~~~~~~~~~~')
threading.Thread(target=woek).start()
从运行结果来看,另一个线程打印global_data.x出错了。
AttributeError: '_thread._local' object has no attribute 'x'
但是,global_data打印没有出错,说明看到global_data,但是global_data中的x看不到,这个x不能跨进程。
threading.local类构建了一个大字典,存放所有线程相关的字典定义如下:
{id(Thread)->(ref(Thread),thread-locla dict)}
每一个线程实例的id为key,元组为value。
value中有两部分,线程对象引用,每个线程自己的字典。