python多线程：Thread类的用法

逃离我推掉我的手 2022-11-05 11:47 28阅读 0赞

我们要创建Thread对象，然后让他们运行，每个Thread对象代表一个线程，在每个线程中我们可以让程序处理不同的任务，这就是多线程编程。

> 创建Thread对象有两种方法：  
> 1.直接创建Thread，将一个callable对象从类的构造器传递出去，这个callable就是回调函数，用来处理任务。  
> 2.编写一个自定义类继承Thread，然后复写run()方法，在ru()方法中编写任务处理代码，然后创建Thread的子类。

## 1.直接创建Thread对象 ##

# 导入Python标准库中的Thread模块 
    from threading import Thread 
    # 创建一个线程 
    mthread = threading.Thread(target=function_name, args=(function_parameter1, function_parameterN)) 
    # 启动刚刚创建的线程 
    mthread .start()

参数说明：  
function\_name: 需要线程去执行的方法名  
args: 线程执行方法接收的参数，该属性是一个元组，如果只有一个参数也需要在末尾加逗号。  
**1)创建多线程**  
Thread的构造方法中，最重要的参数是target,所以我们需要将一个callable对象赋值给它，线程才能正常运行。  
如果要让一个Thread对象启动，调用它的start()方法即可。

import threading
    import time
    def test():
        for i in range(5):
            print('The {} child thile '.format(i))
            time.sleep(1)
    thread = threading.Thread(target=test)
    thread.start()
    # thread.join()
    
    for i in range(5):
        print('The {} main thile '.format(i))
        time.sleep(1)

上面代码很简单，在主线程上打印 5 次，在一个子线程上打印 5 次。

The 0 child thile The 0 main thile 
    
    The 1 child thile The 1 main thile 
    
    The 2 child thile 
    The 2 main thile 
    The 3 main thile The 3 child thile 
    
    The 4 child thile 
    The 4 main thile

上面的 callable 没有参数，如果需要传递参数的话，args 是固定参数，kwargs 是可变参数。

**2)Thread的名字**

> 每一个Thread都有一个name的属性，代表的就是线程的名字，这个可以在构造方法中赋值。如果在构造方法中没有为name赋值的话，默认就是“Thread-N”的形式，N是数字。

import threading
    import time
    def test():
        for i in range(5):
            print(threading.current_thread().name+" test ",i)
            time.sleep(1)
    thread=threading.Thread(target=test)
    thread.start()
    for i in range(5):
        print("This is "+threading.current_thread().name+"main ",i)
        time.sleep(1)

输出为：

Thread-1 test This is MainThreadmain   00
    
    Thread-1 test  1
    This is MainThreadmain  1
    Thread-1 test  2
    This is MainThreadmain  2
    This is MainThreadmain  3Thread-1 test 
     3
    Thread-1 test  4
    This is MainThreadmain  4

在Thread对象创建时，给name赋值

thread = threading.Thread(target=test,name='aoligei')

运行结果为：

aoligei test This is MainThreadmain   00
    
    This is MainThreadmain  1
    aoligei test  1
    This is MainThreadmain  2
    aoligei test  2
    This is MainThreadmain  3
    aoligei test  3
    This is MainThreadmain  4
    aoligei test  4

**3)Thread的生命周期**

> 1.创建对象时，代表Thread内部被初始化  
> 2.调用start()方法后，thread会开始运行  
> 3.thread代码正常运行结束或者遇到异常，线程会终止。  
> 可以通过Thread的is\_alive()方法查询线程是否还在运行。is\_alive() 返回 True 的情况是 Thread 对象被正常初始化，start() 方法被调用，然后线程的代码还在正常运行。

import threading
    import time
    def test():
        for i in range(5):
            print(threading.current_thread().name+' test ',i,"*"*10)
            time.sleep(0.5)
    
    thread = threading.Thread(target=test,name='aoligei')
    thread.start()
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.is_alive())
        time.sleep(1)

设置子线程的睡眠时间更短，可以让它早点结束

aoligei test MainThread main   00
     aoligei is alive ********** 
    True
    aoligei test  1 **********
    MainThread main  1
    aoligei is alive  True
    aoligei test  2 **********
    aoligei test  3 **********
    MainThread main  2
    aoligei is alive  True
    aoligei test  4 **********
    MainThread main  3
    aoligei is alive  False
    MainThread main  4
    aoligei is alive  False

**4)join()方法提供阻塞手段**

import threading
    import time
    def test():
        for i in range(5):
            print(threading.current_thread().name+' test ',i,"*"*10)
            time.sleep(2)
    
    thread = threading.Thread(target=test,name='aoligei')
    thread.start()
    thread.join()
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.is_alive())
        time.sleep(1)

调用一个 Thread 的 join() 方法，可以阻塞自身所在的线程。主线程创建了 aoligei 对象后，让其 start，然后通过调用 join() 方法，实现等待。程序运行结果如下：

aoligei test  0 **********
    aoligei test  1 **********
    aoligei test  2 **********
    aoligei test  3 **********
    aoligei test  4 **********
    MainThread main  0
    aoligei is alive  False
    MainThread main  1
    aoligei is alive  False
    MainThread main  2
    aoligei is alive  False
    MainThread main  3
    aoligei is alive  False
    MainThread main  4
    aoligei is alive  False

默认情况下，join()会一直等待对应线程的结束，但可以通过参数赋值，等待规定的时间即可。

def join(self.timeout=None):

timeout是一个浮点参数，单位是秒。

**5)守护线程**

import threading
    import time
    def test():
        for i in range(5):
            print(threading.current_thread().name+' test ',i,"*"*10)
            time.sleep(2)
    
    thread = threading.Thread(target=test,name='aoligei')
    thread.start()
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.is_alive())
        time.sleep(1)

输出为：

aoligei test MainThread main   00 
    **********aoligei is alive 
     True
    MainThread main  1
    aoligei is alive  True
    aoligei test  1 **********
    MainThread main  2
    aoligei is alive  True
    MainThread main  3
    aoligei is alive  True
    aoligei test  2 **********
    MainThread main  4
    aoligei is alive  True
    aoligei test  3 **********
    aoligei test  4 **********

--------------------

> MainThread结束运行后，aoligei仍然在运行，这是因为MainThread在等待其他线程的结束。  
> aoligei的daemon属性默认为False，这使得 MainThread 需要等待它的结束，自身才结束。  
> **如果要达到守护线程（MainThread 结束，子线程也立马结束），怎么做呢？** 其实很简单，只需要在子线程调用 start() 方法之前设置 daemon 就好了。 当然也可以在子线程的构造器中传递 daemon 的值为 True。

thread = threading.Thread(target=test,name='TestThread',daemon=True)
    # thread.setDaemon(True)

修改之后运行结果为：

aoligei test MainThread main   00 
    aoligei is alive ********** 
    True
    MainThread main  1
    aoligei is alive  True
    aoligei test  1 **********
    MainThread main  2
    aoligei is alive  True
    MainThread main  3
    aoligei is alive  True
    aoligei test  2 **********
    MainThread main  4
    aoligei is alive  True

**6)线程数量**  
threading.enumerate()：返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

> **def enumerate():**  
> “”"Return a list of all Thread objects currently alive.  
> The list includes daemonic threads, dummy thread objects created by current\_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started.

import threading
    import time
    def func1():
        print("This is func1")
        time.sleep(1)
    def func2():
        print("This is func2")
        time.sleep(1)
    
    for i in range(4):
        t1=threading.Thread(target=func1)
        t2 = threading.Thread(target=func2)
        t2.start()
        t1.start()
        le=len(threading.enumerate())
        print("当前线程数为",le)

运行结果为：

This is func2
    This is func1当前线程数为
     3
    This is func2
    This is func1当前线程数为
     5
    This is func2
    This is func1当前线程数为
     7
    This is func2
    This is func1当前线程数为
     9

**7)其他的方法**

> Thread类的其他方法  
> getName()：返回线程名  
> setName(): 设置线程名

> threading模块提供的方法  
> threading.currentThread()：返回当前的线程变量。  
> threading.activeCount()：返回正在运行的线程数量，与len(threading.enumerate()) 有相同的结果

## 2.自定义类继承Thread ##

自定义一个Thread的子类，然后复写它的run()方法

import threading
    import time
    class TestThread(threading.Thread):
        def __init__(self,name=None):
            threading.Thread.__init__(self,name=name)
        def run(self):
            for i in range(5):
                print(threading.current_thread().name+" test ",i)
                time.sleep(1)
    thread=TestThread(name='aoligei')
    thread.start()
    
    for i in range(5):
        print(threading.current_thread().name+" main ",i)
        time.sleep(1)

自定义了 TestThread 这个类，然后继承threading.Thread 只有在 run() 方法中处理逻辑，最终运行结果如下：

aoligei test MainThread main   00
    
    aoligei test MainThread main   1
    1
    MainThread main  2
    aoligei test  2
    aoligei test  3
    MainThread main  3
    MainThread main  4
    aoligei test  4

参考链接：[Python多线程编程(一）][Python]

[Python]: https://blog.csdn.net/briblue/article/details/85101144