python -- 认识多线程threading模块

最新推荐文章于 2022-08-09 10:39:10 发布
最新推荐文章于 2022-08-09 10:39:10 发布
阅读量219 收藏 1
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CN_LiTianpeng/article/details/117048737
版权

一、了解多线程

  • 线程可以理解成轻量级的进程，是操作系统能够进行运算调度的最小单位，它包含在进程中，是进程的实际运作单位
  • 线程自身并不拥有系统资源，只拥有一些运行中必不可少的资源，但它可以与同一个进程的其他线程共享进程所拥有的的全部资源。
  • 一个线程可以创建和撤销另一个线程，同一个进程中的多个线程可以并发执行

线程有三种基本状态：
1、就绪状态：指线程具备运行的所有条件，逻辑上可以运行，在等待处理机会
2、运行状态：指线程占用处理机会，并正在运行
3、阻塞状态：值线程在等待一个事件（如某个信号量），逻辑上不可执行
在这里插入图片描述

由于GIL(全局解释器锁)的存在，python的多线程只能调用一个CPU，因此在当今多核的情况下，成为了一个缺陷。因此在执行计算密集型任务时，适合使用多进程；当执行I/O密集型任务时，适合使用多线程

1.计算密集型的多进程和多线程比较

1.1、多进程

from multiprocessing import Process
import time
import os

# 计算密集型任务
def work():
    res = 0
    for i in range(100000000):
        res *= i

if __name__ == '__main__':
    l = []
    print(f"本机为{os.cpu_count()}核cpu机器")        # 本机为12核cpu机器
    start = time.time()
    for i in range(4):
        p = Process(target=work)
        l.append(p)
        p.start()

    for i in l:
        i.join()

    end = time.time()

    print("计算密集型任务，多进程耗时：%s" % (end - start))

执行结果：耗时5.4秒

本机为12核cpu机器
计算密集型任务，多进程耗时：5.387600898742676

1.2、执行多线程

from threading import Thread
import time
import os

# 计算密集型任务
def work():
    res = 0
    for i in range(100000000):
        res *= i

if __name__ == '__main__':
    l = []
    print(f"本机为{os.cpu_count()}核cpu机器")        # 本机为12核cpu机器
    start = time.time()
    for i in range(4):
        p = Thread(target=work)
        l.append(p)
        p.start()

    for i in l:
        i.join()

    end = time.time()

    print("计算密集型任务，多进程耗时：%s" % (end - start))

执行结果：执行时间为16.3秒，在执行计算密集型任务，比多线程慢了近近3倍。

本机为12核cpu机器
计算密集型任务，多进程耗时：16.26915717124939

2.I/O密集型的多进程和多线程比较

2.1、执行多进程

from multiprocessing import Process
import time
import os

# I/O密集型任务
def work():
    time.sleep(2)
    print("===>", file=open("tmp.txt", "w"))

if __name__ == '__main__':
    l = []
    print(f"本机为{os.cpu_count()}核cpu机器")        # 本机为12核cpu机器
    start = time.time()
    for i in range(4):
        p = Process(target=work)
        l.append(p)
        p.start()

    for i in l:
        i.join()

    end = time.time()

    print("计算密集型任务，多进程耗时：%s" % (end - start))

执行结果：执行耗时2.1秒

本机为12核cpu机器
计算密集型任务，多进程耗时：2.137941837310791

2.3、执行多线程

from threading import Thread
import time
import os

# I/O密集型任务
def work():
    time.sleep(2)
    print("===>", file=open("tmp.txt", "w"))     # 将 ===》 写入到 tmp.txt文件

if __name__ == '__main__':
    l = []
    print(f"本机为{os.cpu_count()}核cpu机器")        # 本机为12核cpu机器
    start = time.time()
    for i in range(4):
        p = Thread(target=work)
        l.append(p)
        p.start()

    for i in l:
        i.join()

    end = time.time()

    print("计算密集型任务，多进程耗时：%s" % (end - start))

执行结果：执行I/O密集型任务，比多进程快了一些

本机为12核cpu机器
计算密集型任务，多进程耗时：2.0026445388793945

二、多线程threading模块

  • python提供的多线程模块有两个：threading 和 _thread，threading是对_thread的封装，功能更强大

1、示例1:通过函数的方式执行多线程：

import threading
import time

def task_thread(counter):
    print(f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
    num = counter
    while num:
        time.sleep(2)
        num -= 1
    print(f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')


if __name__ == '__main__':
    print(f"主线程开始时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

    # 实例化3个线程，传入不同的参数
    t1 = threading.Thread(target=task_thread, args=(3,))
    t2 = threading.Thread(target=task_thread, args=(2,))
    t3 = threading.Thread(target=task_thread, args=(1,))
    t1.start()
    t2.start()
    t3.start()
    t1.join()
    t2.join()
    t3.join()
    print(f"主线程结束时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

执行结果：

主线程开始时间：2021-05-19 23:57:46
线程名称：Thread-1 参数：3 开始时间：2021-05-19 23:57:46
线程名称：Thread-2 参数：2 开始时间：2021-05-19 23:57:46
线程名称：Thread-3 参数：1 开始时间：2021-05-19 23:57:46

线程名称：Thread-3 参数：1 结束时间：2021-05-19 23:57:48

线程名称：Thread-2 参数：2 结束时间：2021-05-19 23:57:50

线程名称：Thread-1 参数：3 结束时间：2021-05-19 23:57:52
主线程结束时间：2021-05-19 23:57:52

Process finished with exit code 0

2.示例2:通过类的方式执行多线程

  • 继承Thread类实现多线程
import threading
import time

class Mythread(threading.Thread):
    def __init__(self, counter):
        super().__init__()            # 调用父类的__init__()方法
        self.counter = counter

    def run(self):
        print(f'线程名称：{threading.current_thread().name} 参数：{self.counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
        num = self.counter
        while num:
            time.sleep(2)
            num -= 1
        print(f'线程名称：{threading.current_thread().name} 参数：{self.counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')


if __name__ == '__main__':
    print(f"主线程开始时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

    # 实例化3个线程，传入不同的参数
    t1 = Mythread(3)
    t2 = Mythread(2)
    t3 = Mythread(1)
    t1.start()
    t2.start()
    t3.start()
    t1.join()
    t2.join()
    t3.join()
    print(f"主线程结束时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

执行结果

主线程开始时间：2021-05-20 00:05:13
线程名称：Thread-1 参数：3 开始时间：2021-05-20 00:05:13
线程名称：Thread-2 参数：2 开始时间：2021-05-20 00:05:13
线程名称：Thread-3 参数：1 开始时间：2021-05-20 00:05:13

线程名称：Thread-3 参数：1 结束时间：2021-05-20 00:05:15

线程名称：Thread-2 参数：2 结束时间：2021-05-20 00:05:17

线程名称：Thread-1 参数：3 结束时间：2021-05-20 00:05:19
主线程结束时间：2021-05-20 00:05:19

Process finished with exit code 0

3.示例3:多线程的类方法中引入类外的函数

  • 通过self.target来接收外部函数，self.args来接收传入外部函数内的参数
  • 通过self.target(*self.args) 实现调用外部函数
  • self.target 其实就是外部函数的内存地址
import threading
import time

# 定义外部函数
def out_func(counter):
    print(f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
    num = counter
    while num:
        time.sleep(2)
        num -= 1
    print(f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')


class Mythread(threading.Thread):
    def __init__(self, target, args):
        super().__init__()
        self.target = target
        self.args = args

    def run(self):
        self.target(*self.args)   # *self.args,打散args参数

if __name__ == '__main__':
    print(f"主线程开始时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

    # 实例化3个线程，传入不同的参数
    t1 = Mythread(target=out_func, args=(3,))
    t2 = Mythread(target=out_func, args=(2,))
    t3 = Mythread(target=out_func, args=(1,))
    t1.start()
    t2.start()
    t3.start()
    t1.join()
    t2.join()
    t3.join()
    print(f"主线程结束时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")

执行结果：

主线程开始时间：2021-05-20 00:13:06
线程名称：Thread-1 参数：3 开始时间：2021-05-20 00:13:06
线程名称：Thread-2 参数：2 开始时间：2021-05-20 00:13:06
线程名称：Thread-3 参数：1 开始时间：2021-05-20 00:13:06

线程名称：Thread-3 参数：1 结束时间：2021-05-20 00:13:08

线程名称：Thread-2 参数：2 结束时间：2021-05-20 00:13:10

线程名称：Thread-1 参数：3 结束时间：2021-05-20 00:13:12
主线程结束时间：2021-05-20 00:13:12

Process finished with exit code 0
知无涯学无尽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
100天精通Python（进阶篇）——第37天：多线程threading模块基础+代码实战
努力让自己发光，对的人才能迎着光而来
05-09 1万+
一、多任务介绍 二、多任务的概念 三、threading 模块介绍 1. Thread类使用说明 2. 实例化 threading.Thread（重点） 3. 继承 threading.Thread 4. 多线程 - 共享全局变量（重点） 5. 多线程-共享全局变量问题 6. 线程同步概念 7. 互斥锁（重点） 8. 死锁...
python中的线程
weixin_44540204的博客
02-28 118
1。什么是线程： 线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。 举个简单的例子来理解下： 假定有一 7 * 24 小时不停工的工厂，由于其...
python 包之 threading 多线程教程
cmdos的专栏
04-01 256
一、创建一个线程通过实例化threading.Thread类创建线程import threadingdef func(s): print(s)if __name__ == '__main__': # 创建线程 thread = threading.Thread(target=func, args=('hello',)) # 启动线程 thread.start() # 等待线程结束 thread.join()二、创建多个线程import threadingdef func(s): print.
python 多线程模块,Python模块学习之thread多线程处理
weixin_36228865的博客
03-25 308
标准库提供了和threading两个模块来对多线程进行支持。其中，thread模块以低级、原始的方式来处理和控制线程，而threading模块通过对thread进行二次封装，提供了更方便的api来处理线程。虽然使用thread没有threading来的方便，但它更灵活。今天先介绍thread模块的基本使用。在介绍 thread 之前，先看一段代码，猜猜程序运行完成之后，在控制台上输出的结果是什么？...
Python之threading的多线程与线程同步
秃秃的测试
04-14 702
创建多线程 import threading import time def a(): for i in range(5): print('1') time.sleep(1) def b(): for i in range(5): print('2') time.sleep(2) if __name__...
Python多线程threading模块用法实例分析
09-19
主要介绍了Python多线程threading模块用法,结合实例形式分析了Python多线程threading模块原理、功能、常见应用及相关操作注意事项,需要的朋友可以参考下
python多线程-threading模块.pdf
11-24
python多线程-threading模块.pdf
python threading模块操作多线程介绍
09-22
主要介绍了python threading模块操作多线程介绍,本文给出简单使用实例,需要的朋友可以参考下
Python多线程threading和multiprocessing模块实例解析
09-20
主要介绍了Python多线程threading和multiprocessing模块等相关内容，分享了相关代码示例，小编觉得还是挺不错的，这里分享给大家，需要的朋友可以参考下
Python多线程模块Threading用法示例小结
09-18
主要介绍了Python多线程模块Threading用法,结合实例形式分析了Python多线程模块Threading相关概念、原理、进程与线程的区别及使用技巧,需要的朋友可以参考下
【Python】多线程及threading模块介绍
sinat_41752325的博客
08-09 1771
python中的多线程同步问题及互斥锁使用，和可能出现的死锁情况
Python多线程实例|threading模块
HRD的博客
11-30 872
Python多线程实例|threading模块实例 代码 import time import threading def task_thread(counter): print('线程名称：{} 参数：{} 开始时间：{}'.format(threading.current_thread().name,counter,time.strftime("%Y-%m-%d %H:%M:%S"))) num = counter while num: time.slee
python 多线程、多进程、协程相关知识点
weixin_43571751的博客
09-20 367
线程与进程 进程与线程的区别： 进程是系统资源分配的最小单位，线程是程序执行的最小单位； 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行分支； 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见； 调度和切换：线程上下文切换比进程上下文切换要快得多。 GIL 什么GIL GIL的全称是 Global Interpreter Lock，全局解释器锁，之所以叫这个名字，是因为Pyt
多个CPU和多核CPU以及超线程（Hyper-Threading）详解
踩风火轮的乌龟
01-15 2万+
在这篇文章中我会主要介绍CPU相关的一些重要概念和技术。如果你想更好地了解操作系统，那就从本文开始吧。
python 多线程编程
每日三省吾身
09-07 1314
今天来学习Python中另一个操作线程的模块：threading。threading通过对thread模块进行二次封装，提供了更方便的API来操作线程。今天内容比较多，闲话少说，现在就开始切入正题！ threading.Thread Thread 是threading模块中最重要的类之一，可以使用它来创建线程。有两种方式来创建线程：一种是通过继承Thread类，重写它的run方法；另一种是创...
python threading.enumerate()查看线程数量（多线程二）
zhujuntangxiaojuan的博客
08-11 1万+
""" # 拆包enumerate返回值是一个元组 names = ["aa", "bb", "cc"] for i, name in enumerate(names): print(i, name) """ import threading import time def test1(): for i in range(5): print("-----tes...
python多线程
weixin_34415923的博客
11-11 180
python多线程详解 Python-Socket网络编程 1. thread模块 python是支持多线程的, 主要是通过thread和threading这两个模块来实现的。 python的thread模块是比较底层的模块(或者说轻量级)，python的threading模块是对thread做了一些包装的，可以更加方便的被使用。 简要的看一下thread模块中含函数和常量 import ...
python学习：counter计数
热门推荐
十五楼亮哥
01-27 3万+
一：定义一个数组，求数组中每个元素出现的次数 如果用java来实现，是一个比较复杂的，需要遍历数组。 但是python很简单：看代码 a = [1,4,2,3,2,3,4,2] from collections import Counter print Counter(a) 打印结果： Counter({2: 3, 3: 2, 4: 2, 1: 1}) 结果表示：元素2出现了
python-网络编程 （个人学习笔记1.1）--python中的多线程(threading模块)
ChengJiang_09的博客
11-06 336
文章目录一、多线程提要1.什么是多线程2.python多线程须知:(1) python多线程弊端(2)python多线程利用二、多线程(threading模块) 一、多线程提要 1.什么是多线程 多线程：原本需要按先后执行的两个程序，在同一时刻同时进行，每个在同时执行的程序，称为一个线程。 在实际运行中，因为CPU同一时间只能执行一项运算，这时CPU就会将两个程序的执行进行拆分，即：每过极其短暂的一段时间，交替执行不同的两个程序，从视觉上，给人一种同时进行的感觉。 2.python多线程须知: (1)
gopython 多线程问题_python--threading多线程
最新发布
06-07
好的，关于 Python 中的多线程问题，可以使用 `threading` 模块来实现。`threading` 模块提供了 `Thread` 类，可以用于创建线程。可以通过以下步骤来使用 `threading` 模块实现多线程： 1. 导入 `threading` 模块。 2. 创建一个 `Thread` 对象，构造函数的参数为需要执行的函数和函数的参数。 3. 调用 `start()` 方法来启动线程，该方法会调用传递给 `Thread` 对象的函数。 4. 可以使用 `join()` 方法来等待线程执行完成。 需要注意的是，由于 Python 全局解释器锁（GIL）的存在，Python 中的多线程并不能真正意义上的并行执行，而是通过线程之间的切换来模拟并行执行。 希望我回答的是否符合您的要求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值