Python多线程中的threading

迈不过友情╰ 2022-11-27 08:57 154阅读 0赞

前言：在前面的博文里，我介绍了实现Python多任务的一种方式——多进程，那么本博文将介绍另一种方式——多线程。

### 文章目录 ###

*   *  一、使用threading模块
     *   *  1.1 使用threading模块
         *   *  1.1.1 单线程执行
             *  1.1.2 多线程执行
         *  1.2 主线程会等待所有的子线程结束后才结束
         *  1.3 查看线程数量
     *  二、多线程中的注意点
     *   *  2.1 线程执行代码的封装
         *  2.2 线程的执行顺序
         *  2.3 线程的总结
     *  三、多线程共享全局变量
     *   *  3.1 好处
         *  3.2 缺点

## 一、使用threading模块 ##

Python的thread模块是比较底层的模块，Python的`threading`模块是对thread做了一些包装的，可以更加方便的被使用。

### 1.1 使用threading模块 ###

#### 1.1.1 单线程执行 ####

import time
    
    
    def saySorry():
        print("我在学Python，你呢？")
        time.sleep(1)
    
    
    if __name__ == "__main__":
        for i in range(3):
            saySorry()

![在这里插入图片描述][20200814180127777.png_pic_left]

#### 1.1.2 多线程执行 ####

import threading
    import time
    
    
    def saySorry():
        print("我在学Python，你呢？")
        time.sleep(1)
    
    
    if __name__ == "__main__":
        for i in range(3):
            t = threading.Thread(target=saySorry)
            # 启动线程，即让线程开始执行
            t.start()

![在这里插入图片描述][20200814180256817.png_pic_left]  
**说明：**

1.  可以明显看出使用了多线程并发的操作，花费时间要短很多。
2.  当调用`start()`时，才会真正的创建线程，并且开始执行。

### 1.2 主线程会等待所有的子线程结束后才结束 ###

import threading
    from time import sleep, ctime
    
    
    def sing():
        for i in range(3):
            print("正在唱歌...%d" % i)
            sleep(1)
    
    
    def dance():
        for i in range(3):
            print("正在跳舞...%d" % i)
            sleep(1)
    
    
    if __name__ == '__main__':
        print('---开始---:%s' % ctime())
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
    
        t1.start()
        t2.start()
    
        # sleep(5) # 打开此行代码，再次执行程序，对比区别。
        print('---结束---:%s' % ctime())

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left]

### 1.3 查看线程数量 ###

import threading
    from time import sleep, ctime
    
    
    def sing():
        for i in range(3):
            print("正在唱歌...%d" % i)
            sleep(1)
    
    
    def dance():
        for i in range(3):
            print("正在跳舞...%d" % i)
            sleep(1)
    
    
    if __name__ == '__main__':
        print('---开始---:%s' % ctime())
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
    
        t1.start()
        t2.start()
    
        while True:
            length = len(threading.enumerate())
            print('当前运行的线程数为：%d' % length)
            if length <= 1:
                break
    
            sleep(0.5)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left 1]

## 二、多线程中的注意点 ##

### 2.1 线程执行代码的封装 ###

通过上一部分，我们能够看出：通过使用`threading`模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用`threading`模块时，往往会定义一个新的子类class，只要继承`threading.Thread`就可以了，然后重写`run`方法，示例如下：

import threading
    import time
    
    
    class MyThread(threading.Thread):
        def run(self):
            for i in range(3):
                time.sleep(1)
                msg = "I'm " + self.name + ' @ ' + str(i)  # name属性中保存的是当前线程的名字
                print(msg)
    
    
    if __name__ == '__main__':
        t = MyThread()
        t.start()

![在这里插入图片描述][20200814182015611.png_pic_left]  
**说明：**

*  Python的`threading.Thread`类有一个`run`方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的`start`方法，可以启动该线程，交给Python虚拟机进行调度，当该线程获得执行的机会时，就会调用`run`方法执行线程。

### 2.2 线程的执行顺序 ###

import threading
    import time
    
    
    class MyThread(threading.Thread):
        def run(self):
            for i in range(3):
                time.sleep(1)
                msg = "I'm " + self.name + ' @ ' + str(i)
                print(msg)
    
    
    def test():
        for i in range(3):
            t = MyThread()
            t.start()
    
    
    if __name__ == '__main__':
        test()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left 2]  
**说明：**

*  从代码和执行结果我们可以看出：多线程程序的执行顺序是不确定的。当执行到`sleep`语句时，线程将被阻塞（Blocked），到`sleep`结束后，线程进入就绪（Runnable）状态，等待调度。而线程调度将自行选择一个线程执行。上面的代码中只能保证每个线程都运行完整个`run`函数，但是线程的启动顺序、`run`函数中每次循环的执行顺序都不能确定。

### 2.3 线程的总结 ###

1.  每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的`name`，但是Python会自动为线程指定一个名字。
2.  当线程的`run()`方法结束时，该线程完成。
3.  我们无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

## 三、多线程共享全局变量 ##

### 3.1 好处 ###

*  在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据。
 *  缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）。

### 3.2 缺点 ###

*  如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确。

[20200814180127777.png_pic_left]: /images/20221124/a140d2fbe3ed43e3bb3e4efa8125fed2.png
[20200814180256817.png_pic_left]: /images/20221124/361d6afe71144419b23808d357c17e36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left]: /images/20221124/4b0b82db72694a1193f531eaa308381e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left 1]: /images/20221124/eee8f09a3261406292cb9fea90dcc735.png
[20200814182015611.png_pic_left]: /images/20221124/aacdda621f03447ba3b0e7a34cfc73ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDM0Mzg0_size_16_color_FFFFFF_t_70_pic_left 2]: /images/20221124/a8e1934d60414cef83194bdaa749e6f4.png