In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
无论你启动多少个线程,Python解释器在同一时刻,都只允许一个线程在cpu上执行,Python启动一个线程是调用C语言的接口,让操作系统启动线程,所以所有的线程调度是操作系统在执行,而Python解释器在启动线程后只能等待操作系统返回结果。所以Python解释器为了防止同一时刻多个线程操作同一个数据,造成数据混乱,所以在cpython解释器中,加入了global interpreter lock。
注意:Jpython、pypy等解释器都没有GIL
- python 中的多线程虽然不能并行,但是能达到高并发的效果。并不是一无用处
import threading
import time
def run(i): #定义每个线程要运行的函数
print("线程::%s 正在运行" %i)
time.sleep(1)
if __name__ == '__main__':
#注意args参数必须为元组格式,如只有一个参数后面要加括号
t1 = threading.Thread(target= run, args=(1, )) #生成一个线程实例 参数还有name 线程名,daemon 是否守护线程 True
t2 = threading.Thread(target= run, args=(2, )) #生成另一个线程实例
t1.start() #启动线程
t2.start() #启动另一个线程
print(t1.getName()) #获取线程名
print(t2.getName())
当你在启动一个线程之后,前面说过由于是调用系统创建,所以主进程就和创建的线程没有关系了。想象一下如果主进程的执行依赖于线程返回的结果,可是线程执行需要一定时间,当主进程 done 了,线程还没结束。
那就有问题了。所以这个时候 join 的左右就出来了,某个线程实例执行 join 方法,主进程会等到该线程执行完毕再从 join 后开始执行
如:我们生产10个线程。主线程同时等待所以线程执行完毕
def run(i):
print('线程 {} 在运行'.format(i))
time.sleep(1)
if i%2:
print('子线程done....')
thread_list = []
for i in range(10):
t = threading.Thread(target= run, args(i, ))
t.start()
thread_list.append(t)
for t in thread_list:
t.join()
print('main thread done....')
#执行结果为
线程 0 在运行
线程 1 在运行
线程 2 在运行
线程 3 在运行
线程 4 在运行
线程 5 在运行
线程 6 在运行
线程 7 在运行
线程 8 在运行
线程 9 在运行
子线程done....
子线程done....
子线程done....
子线程done....
子线程done....
main thread done....
#如果不使用join 的话 ,结果为...
线程 0 在运行
线程 1 在运行
线程 2 在运行
线程 3 在运行
线程 4 在运行
线程 5 在运行
线程 6 在运行
线程 7 在运行
线程 8 在运行
线程 9 在运行
main thread done....
子线程done....
子线程done....
子线程done....
子线程done....
子线程done....
在这儿我们可以看到,就算没有加 join 主进程还是等待子线程全部执行结束后才结束,但是中间执行类容不会等待,这是因为Python 自动在程序结尾处自动添加了 join
设想一个列子:一个奴隶主创建了很多奴隶,奴隶主就是主进程,奴隶们是子线程,奴隶主只需要告诉奴隶们命令,他们就会去工作。奴隶主在创建奴隶们的时候,就给他们心脏上安了一个东西,告诉他们,只要我死了,不管你们当时在干嘛,这个东西就会工作,立刻杀死你们。意思就是主进程一旦结束,所有被设置为守护进程的子线程全部结束
而在threading 模块中,这个安装到奴隶(子线程,守护进程)的东西就是 daemon = True.
有两种方式实现,一是实例化一个线程时:t = threading.Thread(target= fun, args= ( para , ), daemon= True)
第二种为:必须在线程执行前设置,一旦start 后设置,就会报错
def run(i):
print('线程 {} 在运行'.format(i))
time.sleep(1.5)
print('子线程done....')
for i in range(2):
t = threading.Thread(target= run, args= (i, ))
t.setDaemon(True) #必须在线程执行前设置
t.start()
print('main thread done....')
#运行结果为
线程 0 在运行
线程 1 在运行
main thread done....
从最后的运行结果中可以看到,主进程并没有等着子线程执行完,就结束了!这就是 非守护线程, 守护进程的关系