【Python学习笔记（八）】threading多线程模块的使用_多线程threading模块基础

threading多线程模块的使用

前言

此篇文章介绍 threading多线程模块 的基本使用方法。
threading 模块 是 Python 标准库模块，无需手动安装，可以直接导入 import threading # 导入threading模块。

正文

1、线程和进程的概念

• 进程：进程就是运行着的程序（系统中每一个进行里面至少包含一个线程）。
• 线程：线程是操作系统创建的，每个线程对应一个代码执行的数据结构，保存了代码执行过程中重要的状态信息。

2、线程的分类

1. 内核线程：由操作系统内核创建和撤销。
2. 用户线程：不需要内核支持而在用户程序中实现的线程。

3、threading模块

3.1、创建线程的步骤

1. 导入线程类：from threading import Thread
2. 线程实例化：t=Thread(target=事件函数名) ，创建Thread类的实例对象
3. 开启线程：t.start() ，执行start()方法，就会创建新线程
4. 线程同步：t.join() ，使主线程等待子线程

3.3、创建多线程的步骤

1. 创建多线程的基本步骤：

from threading import  Thread
def threadFunc(): # 事件函数
    pass
t_list=[] # 线程列表
for i in range(5): # 创建5个线程
    t=Thread(target=threadFunc) # 线程实例化
    t_list.append(t) # 添加到线程列表中来
    t.start() # 线程开启
for t in t_list: 
    t.join() # 线程同步
1
2
3
4
5
6
7
8
9
10

2. 以下面代码为示例：先打印主线程开始，然后开启三个子线程，并随机休眠1~3s(float类型)，打印子线程的运行状态，最后打印主线程结束。

import time
import random
from threading import Thread, Lock

print("主线程开始！")

def threadFunc(num):
    """
    子线程
    """
    print(f"线程{num}开启!")
    time.sleep(random.uniform(1,3)) # 随机休眠1~3s
    print(f"线程{num}结束!")

t_list = []
for i in range(3):
    t = Thread(target=threadFunc,args=str(i))  # 创建Thread类的实例对象
    t_list.append(t)  # 添加到线程列表中来
    t.start()  # 执行start()方法，就会创建新线程
for t in t_list:
    t.join()  # 用于线程同步，使主线程等待子线程
print("主线程结束！")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. 运行效果：
   

4、线程同步

4.1、什么是线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程同步。
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire() 和 release() 方法，对于那些需要每次只允许一个线程操作的程序，可以将其操作放到 acquire() 和 release() 方法之间。

4.2、使用线程锁的步骤

• 导入线程锁：from threading import Lock
• 何时加锁：当多个线程操作同一个共享资源时，进行加锁
• 常用方法：
  a、创建锁：lock=Lock()
  b、上锁：lock.acquire() 释放锁：lock.release()
  c、当上锁成功后，未释放锁之前，再次上锁就会阻塞

4.3、使用线程锁的示例

• 定义一个全局变量 n=5000，开启两个线程，各循环 1000000 次，分别 +1 ，-1 ，最后打印 n 的值

from threading import Thread, Lock

n = 5000  # 定义一个全局变量
lock = Lock()  # 线程锁实例化


def f1():
    """
    线程1：循环1000000次，全局变量+1
    """
    global n
    for i in range(1000000):
        lock.acquire()  # 上锁
        n += 1
        lock.release()  # 释放锁


def f2():
    """
    线程2：循环1000000次，全局变量-1
    """
    global n
    for i in range(1000000):
        lock.acquire()  # 上锁
        n -= 1
        lock.release()  # 释放锁


t1 = Thread(target=f1)  # 创建线程
t1.start()  # 线程开启
t2 = Thread(target=f2)  # 创建线程
t2.start()  # 线程开启

t1.join()  # 线程同步
t2.join()  # 线程同步
print(n)  # 打印n
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
27
28
29
30
31
32
33
34
35
36

• 最后输出值为：5000
  

• 不加线程锁的运行效果，注释掉上锁&释放锁的语句
  
  
  每次的值均不一样，说明两个线程同时对全局变量 n 操作，出现了不可预料的结果。

5、使用threading模块创建线程

可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用start()方法启动新线程，即它调用了线程的 run() 方法，相当于重写了 run() 方法。