当前位置:   article > 正文

【Python学习笔记(八)】threading多线程模块的使用_多线程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
  1. 以下面代码为示例:先打印主线程开始,然后开启三个子线程,并随机休眠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
  1. 运行效果:
    在这里插入图片描述

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() 方法。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/花生_TL007/article/detail/172508
推荐阅读
相关标签
  

闽ICP备14008679号