Python中创建线程有两种方式:函数或者用类来创建线程对象。
函数式:调用 _thread 模块中的start_new_thread()函数来产生新线程。
类:创建threading.Thread的子类来包装一个线程对象。
1.线程的创建
1.1 通过thread类直接创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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)
|
在这段程序里,一个函数会先休眠几秒钟,然后再打印一句话,第二个函数也是先休眠几秒钟,然后打印一句话。
接着程序会实例化两个线程,并调用两个函数来执行,最后会打印程序问总共执行了多少时间
程序运行结果如下:
1
2
3
4
|
ending
cost time: 0.002000093460083008
foo func: 3
bar func: 5
|
程序会先运行父线程,打印"ending",然后打印程序执行父线程的时间,最后才会运行子线程
1.2 通过thread类来继承式创建
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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方法之后定义
在第一个例子中加入两行代码,如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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)
|
再次执行程序,运行结果如下:
1
2
3
4
|
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随同主线程关闭,代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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)
|
程序运行结果如下 :
1
2
3
4
|
foo start
bar start
ending
cost time: 0.003000020980834961
|
可以看到,把t1和t2都声明为守护线程后,程序自上而下执行,先执行子线程t1中的foo方法,打印foo函数中的第一条打印语句,然后子线程t1进入到睡眠状态。
然后子线程t2执行,打印bar函数中的第一条print语句,然后子线程t2进入睡眠状态,程序切换到主线程运行
主线程打印完"ending"语句,发现子线程t1和t2已经被设置为守护线程,所以主线程不需要再等待两个子线程执行完成,而是立即结束,打印整个程序的执行时间。
整个程序就跟随主线程一起关闭了。
2.3 子线程的一些其他方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
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模块提供的一些方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
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
总结
以上所述是小编给大家介绍的详解python中的线程,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!
原文链接:https://www.cnblogs.com/renpingsheng/p/8437027.html