详解python中的线程

2023-09-16 13:18:04 58

Python中创建线程有两种方式：函数或者用类来创建线程对象。

函数式：调用_thread模块中的start_new_thread()函数来产生新线程。

类：创建threading.Thread的子类来包装一个线程对象。

1.线程的创建

1.1通过thread类直接创建

importthreading
importtime
deffoo(n):
time.sleep(n)
print("foofunc:",n)
defbar(n):
time.sleep(n)
print("barfunc:",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("costtime:",s2-s1)

在这段程序里，一个函数会先休眠几秒钟，然后再打印一句话，第二个函数也是先休眠几秒钟，然后打印一句话。

接着程序会实例化两个线程，并调用两个函数来执行，最后会打印程序问总共执行了多少时间

程序运行结果如下：

ending
costtime:0.002000093460083008
foofunc:3
barfunc:5

程序会先运行父线程，打印"ending",然后打印程序执行父线程的时间，最后才会运行子线程

1.2通过thread类来继承式创建

importthreading
importtime
#定义MyThread类，其继承自threading.Thread这个父类
classMyThread(threading.Thread):
def__init__(self):
threading.Thread.__init__(self)
defrun(self):
print("ok")
time.sleep(2)
print("endt1")
#对类进行实例化
t1=MyThread()
#启动线程
t1.start()
print("ending")

2.Thread类的一些常用方法

2.1join():在子线程完成之前，主线程将一直被阻塞****

线程的join方法必须在子线程的start方法之后定义
在第一个例子中加入两行代码，如下：

importthreading
importtime
deffoo(n):
time.sleep(n)
print("foofunc:",n)
defbar(n):
time.sleep(n)
print("barfunc:",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("costtime:",s2-s1)

再次执行程序，运行结果如下：

foofunc:3
barfunc:5
ending
costtime:5.002285957336426

程序运行到子线程t1中的foo方法时会睡眠3秒钟，与此同时，子线程t2也在睡眠

等到子线程t1睡眠完成后，开始打印foo函数中的print语句，然后子线程t1执行完成

2秒钟之后，子线程t2睡眠完成，开始打印bar函数中的print语句，然后子线程t2也执行完成。

而在这之前，主线程一直处于阻塞状态。等到子线程执行完成之后主线程才会执行

2.2setDeamon(True)

setDaemon方法作用是将进程声明为守护线程，必须在`start()`方法调用之前，
如果不设置为守护线程，程序会被无限挂起

在程序执行过程中，执行一个主线程，主线程又创建一个子线程时，主线程和子线程会分别运行。

当主线程运行完成时，会检验子线程是否执行完成，如果子线程执行完成，则主线程会等待子线程完成后再退出。

但是有的时候只要主线程执行完成之后，不管子线程是否执行完成，都和主线程一起退出，这个就需要调用setDeamon方法了。

拿第一个例子来说吧，现在我想让子线程t1和t2随同主线程关闭，代码如下：

importthreading
importtime
deffoo(n):
print("foostart")
time.sleep(n)
print("fooend...")
defbar(n):
print("barstart")
time.sleep(n)
print("barend...")
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("costtime:",s2-s1)

程序运行结果如下：

foostart
barstart
ending
costtime:0.003000020980834961

可以看到，把t1和t2都声明为守护线程后，程序自上而下执行，先执行子线程t1中的foo方法，打印foo函数中的第一条打印语句，然后子线程t1进入到睡眠状态。

然后子线程t2执行，打印bar函数中的第一条print语句，然后子线程t2进入睡眠状态，程序切换到主线程运行

主线程打印完"ending"语句，发现子线程t1和t2已经被设置为守护线程，所以主线程不需要再等待两个子线程执行完成，而是立即结束，打印整个程序的执行时间。

整个程序就跟随主线程一起关闭了。

2.3子线程的一些其他方法

isAlive()#判断一个线程是否是活动线程
getName()#返回线程的名字
setName()#设置线程的名字
importthreading
importtime
deffoo(n):
time.sleep(n)
print("foofunc:",n)
defbar(n):
time.sleep(n)
print("barfunc:",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("costtime:",s2-s1)

程序执行结果：

线程还未启动时，判断t1是否是活动的线程：False
线程已启动时，判断t1是否是活动的线程：True
修改前的线程名为：Thread-1
修改后的线程名为：t1
foofunc:3
线程执行完成时，判断t1是不否是活动的线程：False
ending
costtime:3.001171588897705

3.threading模块提供的一些方法

threading.currentThread()#返回当前的线程变量
threading.enumerate()#返回一个包含正在运行的线程的列表，不包括启动前和终止后的线程
threading.activeCount()#返回正在运行的线程数量，等同于len(threading.enumerate())
importthreading
importtime
deffoo(n):
time.sleep(n)
print("foofunc:",n)
defbar(n):
time.sleep(n)
print("barfunc:",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("costtime:",s2-s1)

程序执行结果：

程序中正在运行的线程数量：3
程序中当前的线程变量：<_MainThread(MainThread,started7064)>
当前正在运行的线程的列表：[<_MainThread(MainThread,started7064)>,,]
ending
costtime:0.002000093460083008

总结

以上所述是小编给大家介绍的详解python中的线程，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！

详解python中的线程

热门推荐

随机推荐