1. 线程的创建
1.1 通过 thread 类直接创建
- import threading
- import time
- def foo(n):
- time.sleep(n)
- print("foo func:",n)
- def bar(n):
- time.sleep(n)
- print("bar func:",n)
- s1=time.time()
- #创建一个线程实例 t1,foo 为这个线程要运行的函数
- t1=threading.Thread(target=foo,args=(3,))
- t1.start() #启动线程 t1
- #创建一个线程实例 t2,bar 为这个线程要运行的函数
- t2=threading.Thread(target=bar,args=(5,))
- t2.start() #启动线程 t2
- print("ending")
- s2=time.time()
- print("cost time:",s2-s1)
在这段程序里, 一个函数会先休眠几秒钟, 然后再打印一句话, 第二个函数也是先休眠几秒钟, 然后打印一句话
接着程序会实例化两个线程, 并调用两个函数来执行, 最后会打印程序问总共执行了多少时间
程序运行结果如下:
- ending
- cost time: 0.002000093460083008
- foo func: 3
- bar func: 5
程序会先运行父线程, 打印 "ending", 然后打印程序执行父线程的时间, 最后才会运行子线程
1.2 通过 thread 类来继承式创建
- import threading
- import time
- # 定义 MyThread 类, 其继承自 threading.Thread 这个父类
- class MyThread(threading.Thread):
- def __init__(self):
- threading.Thread.__init__(self)
- def run(self):
- print("ok")
- time.sleep(2)
- print("end t1")
- # 对类进行实例化
- t1=MyThread()
- # 启动线程
- t1.start()
- print("ending")
2. Thread 类的一些常用方法
2.1 join(): 在子线程完成之前, 主线程将一直被阻塞 ****
线程的 join 方法必须在子线程的 start 方法之后定义
在第一个例子中加入两行代码, 如下:
- import threading
- import time
- def foo(n):
- time.sleep(n)
- print("foo func:",n)
- def bar(n):
- time.sleep(n)
- print("bar func:",n)
- s1=time.time()
- t1=threading.Thread(target=foo,args=(3,))
- t1.start()
- t2=threading.Thread(target=bar,args=(5,))
- t2.start()
- t1.join() # 阻塞 t1 线程
- t2.join() # 阻塞 t2 线程
- print("ending")
- s2=time.time()
- print("cost time:",s2-s1)
再次执行程序, 运行结果如下:
- foo func: 3
- bar func: 5
- ending
- cost time: 5.002285957336426
程序运行到子线程 t1 中的 foo 方法时会睡眠 3 秒钟, 与此同时, 子线程 t2 也在睡眠
等到子线程 t1 睡眠完成后, 开始打印 foo 函数中的 print 语句, 然后子线程 t1 执行完成
2 秒钟之后, 子线程 t2 睡眠完成, 开始打印 bar 函数中的 print 语句, 然后子线程 t2 也执行完成
而在这之前, 主线程一直处于阻塞状态等到子线程执行完成之后主线程才会执行
2.2 setDeamon(True)
setDaemon 方法作用是将进程声明为守护线程, 必须在 `start()` 方法调用之前,
如果不设置为守护线程, 程序会被无限挂起
在程序执行过程中, 执行一个主线程, 主线程又创建一个子线程时, 主线程和子线程会分别运行
当主线程运行完成时, 会检验子线程是否执行完成, 如果子线程执行完成, 则主线程会等待子线程完成后再退出
但是有的时候只要主线程执行完成之后, 不管子线程是否执行完成, 都和主线程一起退出, 这个就需要调用 setDeamon 方法了
拿第一个例子来说吧, 现在我想让子线程 t1 和 t2 随同主线程关闭, 代码如下:
- import threading
- import time
- def foo(n):
- print("foo start")
- time.sleep(n)
- print("foo end...")
- def bar(n):
- print("bar start")
- time.sleep(n)
- print("bar end...")
- s1 = time.time()
- t1 = threading.Thread(target=foo, args=(3,))
- t1.setDaemon(True)
- t1.start()
- t2 = threading.Thread(target=bar, args=(5,))
- t2.setDaemon(True)
- t2.start()
- print("ending")
- s2 = time.time()
- print("cost time:", s2 - s1)
程序运行结果如下 :
- foo start
- bar start
- ending
- cost time: 0.003000020980834961
可以看到, 把 t1 和 t2 都声明为守护线程后, 程序自上而下执行, 先执行子线程 t1 中的 foo 方法, 打印 foo 函数中的第一条打印语句, 然后子线程 t1 进入到睡眠状态
然后子线程 t2 执行, 打印 bar 函数中的第一条 print 语句, 然后子线程 t2 进入睡眠状态, 程序切换到主线程运行
主线程打印完 "ending" 语句, 发现子线程 t1 和 t2 已经被设置为守护线程, 所以主线程不需要再等待两个子线程执行完成, 而是立即结束, 打印整个程序的执行时间
整个程序就跟随主线程一起关闭了
2.3 子线程的一些其他方法
- isAlive() #判断一个线程是否是活动线程
- getName() #返回线程的名字
- setName() #设置线程的名字
- import threading
- import time
- def foo(n):
- time.sleep(n)
- print("foo func:", n)
- def bar(n):
- time.sleep(n)
- print("bar func:", n)
- s1 = time.time()
- t1 = threading.Thread(target=foo, args=(3,))
- t1.setDaemon(True)
- print("线程还未启动时, 判断 t1 是否是活动的线程:", t1.isAlive()) # 线程还未启动, 所以是 False
- t1.start() # 启动线程
- print("线程已启动时, 判断 t1 是否是活动的线程:", t1.isAlive()) # 线程已启动, 所以是 True
- print("修改前的线程名为:",t1.getName()) # 获取线程名
- t1.setName("t1") #设置线程名
- print("修改后的线程名为:",t1.getName()) # 获取线程名
- t1.join()
- print("线程执行完成时, 判断 t1 是不否是活动的线程:", t1.isAlive()) # 线程已执行完成, 所以是 False
- # print(threading.activeCount())
- print("ending")
- s2 = time.time()
- print("cost time:", s2 - s1)
程序执行结果:
线程还未启动时, 判断 t1 是否是活动的线程: False
线程已启动时, 判断 t1 是否是活动的线程: True
修改前的线程名为: Thread-1
修改后的线程名为: t1
foo func: 3
线程执行完成时, 判断 t1 是不否是活动的线程: False
- ending
- cost time: 3.001171588897705
3.threading 模块提供的一些方法
- threading.currentThread() #返回当前的线程变量
- threading.enumerate() #返回一个包含正在运行的线程的列表, 不包括启动前和终止后的线程
- threading.activeCount() #返回正在运行的线程数量, 等同于 len(threading.enumerate())
- import threading
- import time
- def foo(n):
- time.sleep(n)
- print("foo func:", n)
- def bar(n):
- time.sleep(n)
- print("bar func:", n)
- s1 = time.time()
- t1 = threading.Thread(target=foo, args=(3,))
- t1.setDaemon(True)
- t1.start()
- t2 = threading.Thread(target=bar, args=(5,))
- t2.setDaemon(True)
- t2.start()
- print("程序中正在运行的线程数量:",threading.activeCount())
- print("程序中当前的线程变量:",threading.currentThread())
- print("当前正在运行的线程的列表:",threading.enumerate())
- print("ending")
- s2 = time.time()
- print("cost time:", s2 - s1)
程序执行结果:
程序中正在运行的线程数量: 3
程序中当前的线程变量: <_MainThread(MainThread, started 7064)>
当前正在运行的线程的列表: [<_MainThread(MainThread, started 7064)>, <Thread(Thread-1, started daemon 6384)>, <Thread(Thread-2, started daemon 2640)>]
- ending
- cost time: 0.002000093460083008
来源: https://www.cnblogs.com/renpingsheng/p/8437027.html