Python进阶之多线程的实现方法总结

目录
  • 线程
  • Python中的多线程
    • threading.Thread () 创建线程
    • 继承 threading.Thread 类的线程创建
  • 主线程
    • 使用daemon参数控制过程
    • 使用.join()阻塞线程
  • 线程同步
    • threading中的锁
  • 结语

线程

想要理解线程的含义,首先我们先看一下百度百科的定义:

线程(英语:thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

简单来讲,当你打开电脑中的一个应用程序,其实此时计算机就为你创建了一个进程,系统会为其进行资源分配并且对其进行调度。而线程就是比进程还要小的单位,多个线程完成不同的工作组成了我们宏观上能够得到响应的工作结果。

举个例子,进程就像一个大的工厂,工厂中有很多机床设备和场地。而不同的线程就像工厂中工作的工人,工厂为其分配不同的工作来完成一个最终的生产目标。我们可以指派不同的工人做不同的工作或增加工人提高我们的生产效率。

在编程中,线程可以由我们启用帮助我们完成不同的工作实现多线程并发,提高我们的代码效率。

Python中的多线程

在python中主要有两种实现多线程的方式:

  • 通过threading.Thread () 方法创建线程
  • 通过继承 threading.Thread 类的继承重写run方法

接下来我们分别说一下多线程的两种实现形式。

threading.Thread () 创建线程

为了更直观的理解这个过程,首先我们先编写一个正常的函数,完成倒数5个数的功能,其中间隔一秒钟。

def fuc():
    for i in range(5):
        time.sleep(1)

在主函数中,我们调用Thread()来实例化两个线程,让他们同时运行。

if __name__ == '__main__':
    t1 = threading.Thread(target=fuc, args=(1,), daemon=True)
    t2 = threading.Thread(target=fuc, args=(2,), daemon=True)
    t2.start()
    t1.start()

整体代码如下所示:

import threading
import time

def fuc():
    for i in range(5):
        time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=fuc)
    t2 = threading.Thread(target=fuc)
    t2.start()
    t1.start()

我们先不讨论调用的函数以及传入的参数,先来看一下运行效果:

0
0
11
22
33
44

可以看到,两个打印的结果基本上是同时出现的,并且出现了混合的情况,证明两个打印的函数正在同时进行。

接下来我们就来介绍一下类的初始化参数以及我们调用的函数:

thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)

在该类中主要由以下几个参数组成:

  • group:与ThreadGroup类相关,一般不使用。
  • target:线程调用的对象,就是目标函数,在上述的例子中我们传入的是我们编写的函数fuc。
  • name:线程的名字,默认是Tread-x。
  • args:为目标函数传递关键字参数,字典。
  • daemon:用来设置线程是否随主线程退出而退出,涉及到主线程相关知识,我们稍后介绍。

接下来介绍我们常用的几个方法:

  • run():表示线程启动的活动,在第二种继承写法中会用到。
  • start():激活线程,使其能够被调度。
  • join():等待至线程终止,这个方法涉及到主线程的知识,我们稍后介绍。
  • isAlive():返回线程是否活动。
  • getName():返回线程名称。
  • setName() : 设置线程名称。

接下来,我们使用上述参数更改示例,让函数获取一个参数,并为不同的线程设置名字。代码如下:

import threading
import time

def fuc(num):
    for i in range(5):
        print('接收到参数{}:'.format(num), i)
        time.sleep(1)

if __name__ == '__main__':
	# 传入参数及名字
    t1 = threading.Thread(target=fuc, args=(1,), name='t1')
    t2 = threading.Thread(target=fuc, args=(2,), name='t2')
    t1.start()
    print(t1.getName(), '开始运行...')
    t2.start()
    print(t2.getName(), '开始运行...')

运行结果如下:

接收到参数1:t1 开始运行... 
0
接收到参数2: t20 开始运行...

接收到参数1:接收到参数2: 1 
1
接收到参数1:接收到参数2:  2
2
接收到参数1:接收到参数2:  33

接收到参数1:接收到参数2:  4
4

可以看到,虽然结果很混乱,但是我们传入的参数以及获取的名字都被打印出来了。

另外,这里有两个注意:

  • trgat参数接受的是函数名字不需要加括号。
  • args传入的执行函数参数要加括号和逗号,保证其是一个元组。

继承 threading.Thread 类的线程创建

在上面的例子中,我们已经理解了多线程的一种创建方法。接下来我们来介绍第二种方法,这也是众多大佬很喜欢的一种方法,通过继承 threading.Thread 类的线程创建。

class MyThread(threading.Thread):
    def run(self) -> None:
        for i in range(5):
            print(i)
            time.sleep(1)

if __name__ == '__main__':
    t1 = MyThread(name='t1')
    t2 = MyThread(name='t2')
    t1.start()
    t2.start()

运行结果如下:

0
0
11
22
33
44

注意:这里调用的是start方法而不是run方法,否则会编程单线程执行。

主线程

在了解了多线程的编程方法之后,我们来介绍一下主线程及相关参数和方法。

在我们执行多线程程序的过程中,存在一个主线程,而我们开辟的其他线程其实都是它的子线程。由主线程主导的工作有以下两种情况:

  • 由于主线程结束了,强制停止其它线程的工作,但此时其他线程有可能还没有结束自己的工作。
  • 主线程结束后,等待其他线程结束工作,再停止所有线程的工作。

可以简单地理解为包工头,它是这些线程的头子!其从微观角度上讲掌管了一定的工作流程,它可以选择是否等待其它工人结束工作再结束整个工作。

而我们可以使用参数或者方法控制这个过程。

使用daemon参数控制过程

在上边的函数参数介绍中,提到了daemon参数,其为False时,线程不会随主线程结束而退出,主线程会等待其结束后再退出。而为True时则不论子线程是否完成了相关工作都会直接退出。

接下来我们看两个示例,我们修改刚才的示例代码的daemon参数为True,表示不论子线程是否完成了工作都强制退出。

import threading
import time

def fuc(num):
    for i in range(5):
        print('接收到参数{}:'.format(num), i)
        time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=fuc, args=(1,), name='t1', daemon=True)
    t2 = threading.Thread(target=fuc, args=(2,), name='t2', daemon=True)
    t1.start()
    print(t1.getName(), '开始运行...')
    t2.start()
    print(t2.getName(), '开始运行...')
    print("我是主线程,都给我停下!")

结果如下:

接收到参数1:t1 0 
开始运行...
接收到参数2:t2  0
开始运行...
我是主线程,都给我停下!

可以看到,子线程的倒数还没有结束,由于主线程结束了,所有线程一起结束了。 这里要注意以下几点:

  • daemon属性必须在start( )之前设置。
  • 从主线程创建的所有线程不设置daemon属性,则默认都是daemon=False。

使用.join()阻塞线程

除此之外,我们还可以调用.join()方法阻塞线程,调用该方法的时候,该方法的调用者线程结束后程序才会终止。

#timeout参数表明等待的时长,不设置该参数则默认为一直等待。
join(timeout-=None)

我们来看下面这个示例,我们更改了两个函数的倒计时时间,使第一个线程的倒计时时间更长,并对第二个线程进行了阻塞操作。代码如下:

import threading
import time

def fuc1():
    for i in range(10):
        print(i)
        time.sleep(1)

def fuc2():
    for i in range(5):
        print(i)
        time.sleep(1)

if __name__ == '__main__':
    t1 = threading.Thread(target=fuc1, name='t1', daemon=True)
    t2 = threading.Thread(target=fuc2, name='t2', daemon=True)
    t1.start()
    print(t1.getName(), '开始运行...')
    print('我是二儿子,等等我!')
    t2.start()
    print(t2.getName(), '开始运行...')
    t2.join()
    print("我是主线程,都给我停下!")

结果如下:

0t1
开始运行...
我是二儿子,等等我!
0t2 
开始运行...
11
22
33
44

我是主线程,都给我停下!5

我们可以看到,上述代码中线程一还没有结束倒数十个数,程序就结束了。在此过程中,主线程只等待了第二个线程结束,整个程序就结束了。

线程同步

在多个线程同步运行的情况下,会出现多个线程同时操作一个数据的情况。如果两个线程同时操作同一个变量的话,很容易出现混乱的情况。所以,我们需要一个工具来确保在同一时间只能有一个线程处理数据。

线程类提供了锁来解决问题,当线程申请处理某个数据时申请一个锁来控制住当前数据,结束处理时即将锁释放。

threading中的锁

python的threading中为我们提供了RLock锁来解决多线程同时处理一个数据的问题。在某个时刻,我们可以让线程申请锁来保护数据此时只能供该线程使用。

为了更好的理解该过程,我们定义一个全局变量,让每一个线程都对其操作但不设置锁,观察变量的变化:

R_LOCK = threading.Lock()
COUNT = 100

class MyThread(threading.Thread):
    def run(self) -> None:
        global COUNT
        #R_LOCK.acquire()
        COUNT -= 10
        time.sleep(1)
        print(self.getName(), COUNT)
        #R_LOCK.release()

if __name__ == '__main__':
    threads = [MyThread() for i in range(10)]
    for t in threads:
        t.start()

结果如下:

Thread-3Thread-10  0Thread-8Thread-7 0Thread-6 0Thread-5Thread-9
Thread-1 0Thread-2 00  0
Thread-4 000

可以看到,我们的数据发生了异常,这并不是我们想要得到的结果,若把锁给关闭注释让其正常运行可以看到以下的正常结果:

Thread-1 90
Thread-2 80
Thread-3 70
Thread-4 60
Thread-5 50
Thread-6 40
Thread-7 30
Thread-8 20
Thread-9 10
Thread-10 0

结语

多线程编程是一个非常重要的编程思想,理解多线程编程有助于我们更好的理解设计模式。

当然,python中的编程并不是真正的多线程执行,这涉及到GIL全局解释锁相关的知识。所以其针对CPU密集型任务来说并没有很好的效果,接下来我将会更新相关的内容进行更多的说明。

以上就是Python进阶之多线程的实现方法总结的详细内容,更多关于Python多线程的资料请关注我们其它相关文章!

(0)

相关推荐

  • 多线程python的实现及多线程有序性

    目录 前言 一.多线程运行无序问题 二.“join方法”解决多线程运行无序问题 三.threading.Thread()的常用参数 总结 前言 多线程一般用于同时调用多个函数,cpu时间片轮流分配给多个任务. 优点是提高cpu的使用率,使计算机减少处理多个任务的总时间:缺点是如果有全局变量,调用多个函数会使全局变量被多个函数修改,造成计算错误,这使需要使用join方法或者设置局部变量来解决问题.python使用threading模块来实现多线程,threading.join()方法是保证调用jo

  • python实现多线程的两种方式

    目前python 提供了几种多线程实现方式 thread,threading,multithreading ,其中thread模块比较底层,而threading模块是对thread做了一些包装,可以更加方便的被使用. 2.7版本之前python对线程的支持还不够完善,不能利用多核CPU,但是2.7版本的python中已经考虑改进这点,出现了multithreading  模块.threading模块里面主要是对一些线程的操作对象化,创建Thread的class.一般来说,使用线程有两种模式: A

  • python实现多线程并得到返回值的示例代码

    目录 一.带有返回值的多线程 1.1 实现代码 1.2 结果 二.实现过程 2.1 一个普通的爬虫函数 2.2 一个简单的多线程传值实例 2.3 实现重点 四.学习 一.带有返回值的多线程 1.1 实现代码 # -*- coding:utf-8 -*- """ 作者:wyt 日期:2022年04月21日 """ import threading import requests import time urls = [ f'https://www.

  • python 多线程实现多任务的方法示例

    目录 1 多线程实现多任务 1.1 什么是线程? 1.2 一个程序实现多任务的方法 1.3 多线程的创建方式 1.3.1 创建threading.Thread对象 1.3.2 继承threading.Thread,并重写run 1.4 线程何时开启,何时结束 1.5 线程的 join() 方法 1.6 多线程共享全局变量出现的问题 1.7 互斥锁可以弥补部分线程安全问题.(互斥锁和GIL锁是不一样的东西!) 1.8 线程池ThreadPoolExecutor 1.8.1 创建线程池 1.8.2 

  • python 实现多线程的三种方法总结

    1._thread.start_new_thread(了解) import threading import time import _thread def job(): print("这是一个需要执行的任务.....") print("当前线程的个数:", threading.active_count() ) print("当前线程的信息:", threading.current_thread()) time.sleep(100) if __n

  • Python进阶之多线程的实现方法总结

    目录 线程 Python中的多线程 threading.Thread () 创建线程 继承 threading.Thread 类的线程创建 主线程 使用daemon参数控制过程 使用.join()阻塞线程 线程同步 threading中的锁 结语 线程 想要理解线程的含义,首先我们先看一下百度百科的定义: 线程(英语:thread)是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执

  • python进阶之多线程对同一个全局变量的处理方法

    通常情况下: from threading import Thread global_num = 0 def func1(): global global_num for i in range(1000000): global_num += 1 print('---------func1:global_num=%s--------'%global_num) def func2(): global global_num for i in range(1000000): global_num +=

  • Python实现快速多线程ping的方法

    本文实例讲述了Python实现快速多线程ping的方法.分享给大家供大家参考.具体如下: #!/usr/bin/python #_*_coding:utf-8_*_ # ''' 名称:快速多线程ping程序 开发:gyhong gyh9711 日期:20:51 2011-04-25 ''' import pexpect import datetime from threading import Thread host=["192.168.1.1","192.168.1.123

  • Python基于ThreadingTCPServer创建多线程代理的方法示例

    本文实例讲述了Python基于ThreadingTCPServer创建多线程代理的方法.分享给大家供大家参考,具体如下: #coding=utf8 from BaseHTTPServer import BaseHTTPRequestHandler from SocketServer import ThreadingTCPServer import gzip from StringIO import StringIO import logging logging.basicConfig(level

  • Python进阶学习之特殊方法实例详析

    前言 最近在学习python,学习到了一个之前没接触过的--特殊方法. 什么是特殊方法?当我们在设计一个类的时候,python中有一个用于初始化的方法$__init__$,类似于java中的构造器,这个就是特殊方法,也叫作魔术方法.简单来说,特殊方法可以给你设计的类加上一些神奇的特性,比如可以进行python原生的切片操作,迭代.连乘操作等.在python中,特殊方法以双下划线开始,以双下划线结束. 一个大例子 数学中有一个表示数的概念叫做向量,但是python中的数据类型却没有.我们来设法用p

  • Python实现基于多线程、多用户的FTP服务器与客户端功能完整实例

    本文实例讲述了Python实现基于多线程.多用户的FTP服务器与客户端功能.分享给大家供大家参考,具体如下: 项目介绍: 1. 用户加密认证 2. 允许同时多用户登录 3. 每个用户有自己的家目录 ,且只能访问自己的家目录 4. 对用户进行磁盘配额,每个用户的可用空间不同 5. 允许用户在ftp server上随意切换目录 6. 允许用户查看当前目录下文件 7. 允许上传和下载文件,保证文件一致性 8. 文件传输过程中显示进度条 实现的原理: 服务器端启用端口监听,并对每一连接启用一个线程,对用

  • Python实现的多线程同步与互斥锁功能示例

    本文实例讲述了Python实现的多线程同步与互斥锁功能.分享给大家供大家参考,具体如下: #! /usr/bin/env python #coding=utf-8 import threading import time ''' #1.不加锁 num = 0 class MyThread(threading.Thread): def run(self): global num time.sleep(1) #一定要sleep!!! num = num + 1 msg = self.name + '

  • python 队列基本定义与使用方法【初始化、赋值、判断等】

    本文实例讲述了python 队列基本定义与使用方法.分享给大家供大家参考,具体如下: 队列的特征是:先进先出 应用场景:消息通信.多进程间的协同.多线程间的协同等 在队列中需要设计的实例属性:head节点.tail节点 需要设计的实例方法有两个:分别是入队队列enqueue和出队队列dequeue # -*- coding:utf-8 -*- #! python3 class Node(object): #节点,包括两个属性,一个是节点的值,一个是节点的下一个指向 def __init__(se

  • Python使用正则表达式实现文本替换的方法

    本文实例讲述了Python使用正则表达式实现文本替换的方法.分享给大家供大家参考,具体如下: 2D客户端编程从某种意义上来讲就是素材组织,所以,图片素材组织经常需要批量处理,python一定是最佳选择,不管是win/linux/mac都有一个简单的运行环境 举两个应用场景: ① 如果不是在某个文件夹里面则将文件夹名称插入前面 ② 所有的文件名名称加上一个前缀 直接看代码吧: # encoding: UTF-8 import re # 将正则表达式编译成Pattern对象 p = re.compi

  • Python实现统计文本文件字数的方法

    本文实例讲述了Python实现统计文本文件字数的方法.分享给大家供大家参考,具体如下: 统计文本文件的字数,从当前目录下的file.txt取文件 # -*- coding: GBK -*- import string import sys reload(sys) def compareItems((w1,c1), (w2,c2)): if c1 > c2: return - 1 elif c1 == c2: return cmp(w1, w2) else: return 1 def main()

随机推荐