python3.9多线程_python多线程原理

python3.9多线程_python多线程原理什么是线程?线程也叫轻量级进程,是操作系统能够进行运算调度的最小单位,它被包涵在进程之中,是进程中的实际运作单位。线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

什么是线程?

线程也叫轻量级进程,是操作系统能够进行运算调度最小单位,它被包涵在进程之中,是进程中的实际运作单位。线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程,同一个进程中的多个线程之间可以并发执行
 

为什么要使用多线程?

线程在程序中是独立的并发的执行流。与分隔的进程相比,进程中线程之间的隔离程度要小,它们共享内存、文件句柄 和其他进程应有的状态。 因为线程的划分尺度小于进程,使得多线程程序的并发性高。进程在执行过程之中拥有独立的内存单元,而多个线程共享 内存,从而极大的提升了程序的运行效率。 线程比进程具有更高的性能,这是由于同一个进程中的线程都有共性,多个线程共享一个进程的虚拟空间。线程的共享环境包括进程代码段、进程的共有数据等,利用这些共享的数据,线程之间很容易实现通信。 操作系统在创建进程时,必须为进程分配独立的内存空间,并分配大量的相关资源,但创建线程则简单得多。因此,使用多线程来实现并发比使用多进程的性能高得要多。
 

多线程优点

进程之间不能共享内存,但线程之间共享内存非常容易。操作系统在创建进程时,需要为该进程重新分配系统资源,但创建线程的代价则小得多。因此使用多线程来实现多任务并发执行比使用多进程的效率高 python语言内置了多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了python的多线程编程。
 

单线程执行

import time


def hello():
    print("你好,世界")
    time.sleep(1)


if __name__ == "__main__":
    for i in range(5):
        hello()

运行结果
python3.9多线程_python多线程原理
 

多线程执行

import threading
import time

def saySorry():
    print("你好,世界")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=saySorry)  # 创建线程对象,此时还未启动子线程
        t.start()  # 启动线程,即让线程开始执行

运行结果
python3.9多线程_python多线程原理
 

执行速度对比

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

函数式创建多线程

python中多线程使用threading模块,threading模块调用Thread类

self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None
  • group:默认为None;预留给将来扩展ThreadGroup时使用类实现。不常用,可以忽略
  • target:代表要执行的函数名,不是函数
  • name:线程名,默认情况下的格式是”Thread-N”,其中N是一个小的十进制数
  • args:函数的参数,以元组的形式表示
  • kwargs:关键字参数字典

小例子

import threading
from time import sleep
from datetime import datetime


def write(name):
    for i in range(3):
        print("{}正在写字{}".format(name, i))
        sleep(1)


def draw(name):
    for i in range(3):
        print("{}正在画画{}".format(name, i))
        sleep(1)


if __name__ == '__main__':
    print(f'---开始---:{datetime.now()}')
    t1 = threading.Thread(target=write, args=('Jack', ))
    t2 = threading.Thread(target=draw, args=('Tom', ))
    t1.start()
    t2.start()
    print(f'---结束---:{datetime.now()}')

 

查看线程数量threading.enumerate()

import threading
from datetime import datetime
from time import sleep


def write():
    for i in range(3):
        print(f"正在写字...{i}")
        sleep(1)


def draw():
    for i in range(3):
        print(f"正在画画...{i}")
        sleep(1)


if __name__ == '__main__':
    print(f'---开始---:{datetime.now()}')

    t1 = threading.Thread(target=write)
    t2 = threading.Thread(target=draw)

    t1.start()
    t2.start()

    while True:
        length = len(threading.enumerate())
        print(f'当前运行的线程数为:{length}')
        if length <= 1:
            break
        sleep(0.5)

结果
python3.9多线程_python多线程原理
最开始打印线程数为3个,一个主线程+2个子线程t1,t2
最后打印线程数为1个,是因为子线程都结束了,就剩主线程了
 

自定义线程

继承threading.Thread来定义线程类,其本质是重构Thread类中的run方法
为什么执行run方法,就会启动线程呢?之前写函数时,调用的是start()方法
因为run方法里默认执行了start()方法

import threading
from time import sleep


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


if __name__ == '__main__':
    t = MyThread()
    t.start()

结果
python3.9多线程_python多线程原理
 

守护线程

'''
    这里使用setDaemon(True)把所有的子线程都变成了主线程的守护线程,
    因此当主线程结束后,子线程也会随之结束,所以当主线程结束后,整个程序就退出了。
    所谓’线程守护’,就是主线程不管该线程的执行情况,只要是其他子线程结束且主线程执行完毕,主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。
'''

import threading
import time


def run(n):
    print('task', n)
    time.sleep(1)
    print('3s')
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')


if __name__ == '__main__':
    t = threading.Thread(target=run, args=('t1',))
    t.setDaemon(True)
    t.start()
    print('end')  

结果

task t1
end

通过执行结果可以看出,设置守护线程之后,当主线程结束时,子线程也将立即结束,不再执行

主线程等待子线程结束(join)

为了让守护线程执行结束之后,主线程再结束,我们可以使用join方法,让主线程等待子线程执行

import threading
import time


def run(n):
    print('task', n)
    time.sleep(1)
    print('3s')
    time.sleep(1)
    print('2s')
    time.sleep(1)
    print('1s')


if __name__ == '__main__':
    t = threading.Thread(target=run, args=('t1',))
    t.setDaemon(True)  # 把子线程设置为守护线程,必须在start()之前设置
    t.start()
    t.join()  # 设置主线程等待子线程结束
    print('end')

结果


task t1
3s
2s
1s
end

 

线程共享变量

'''
多线程共享全局变量
线程时进程的执行单元,进程时系统分配资源的最小执行单位,所以在同一个进程中的多线程是共享资源的
'''
import threading
import time

g_num = 0


def work1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work1, g_num is %d---"%g_num)


def work2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work2, g_num is %d---"%g_num)


print("---线程创建之前g_num is %d---"%g_num)

t1 = threading.Thread(target=work1, args=(1000000,))
t1.start()

t2 = threading.Thread(target=work2, args=(1000000,))
t2.start()

while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

结果

---线程创建之前g_num is 0---
----in work2, g_num is 1451293---
----in work1, g_num is 1428085---
2个线程对同一个全局变量操作之后的最终结果是:1428085

先来看结果,为什么不是200000呢?
原因是多线程共用同一个变量,可能会出现资源竞争的问题,导致数据不准确,那有什么解决办法吗?下面介绍互斥锁
 

互斥锁

由于线程之间是进行随机调度,并且每个线程可能只执行n条执行之后,当多个线程同时修改同一条数据时可能会出现脏数据,所以出现了线程锁,即同一时刻允许一个线程执行操作。线程锁用于锁定资源,可以定义多个锁,像下面的代码,当需要独占 某一个资源时,任何一个锁都可以锁定这个资源,就好比你用不同的锁都可以把这个相同的门锁住一样。
 
由于线程之间是进行随机调度的,如果有多个线程同时操作一个对象,如果没有很好地保护该对象,会造成程序结果的不可预期,我们因此也称为线程不安全
 
为了防止上面情况的发生,就出现了互斥锁(Lock)

import threading
import time

g_num = 0
# 创建一个互斥锁
# 默认是未上锁的状态
lock = threading.Lock()

def test1(num):
    global g_num
    for i in range(num):
        lock.acquire()  # 上锁
        g_num += 1
        lock.release()  # 解锁

    print("---test1---g_num=%d"%g_num)


def test2(num):
    global g_num
    for i in range(num):
        lock.acquire()  # 上锁
        g_num += 1
        lock.release()  # 解锁

    print("---test2---g_num=%d"%g_num)

# 创建2个线程,让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()

# 等待计算完成
while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

结果

---test2---g_num=1961182
---test1---g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000

 

上锁解锁过程

当一个线程调用锁的acquire()方法获得锁时,锁就进入locked状态。 每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁,该线程就会变为blocked状态,称为“阻塞”,直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入unlocked状态。 线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态。
 

锁的好处

  • 确保了某段关键代码只能由一个线程从头到尾完整地执行
     

锁的坏处

  • 阻止了多线程并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了
  • 由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁
     

GIL全局解释器

在非python环境中,单核情况下,同时只能有一个任务执行。多核时可以支持多个线程同时执行。但是在python中,无论有多少个核同时只能执行一个线程。究其原因,这就是由于GIL的存在导致的。
 
GIL的全程是全局解释器,来源是python设计之初的考虑,为了数据安全所做的决定。某个线程想要执行,必须先拿到GIL,我们可以把GIL看做是“通行证”,并且在一个python进程之中,GIL只有一个。拿不到通行证的线程,就不允许进入CPU执行。GIL只在cpython中才有,因为cpython调用的是c语言的原生线程,所以他不能直接操作cpu,而只能利用GIL保证同一时间只能有一个线程拿到数据。而在pypyjpython中是没有GIL的
 
python在使用多线程的时候,调用的是c语言的原生过程
 

python针对不同类型的代码执行效率也是不同的

  1. CPU密集型代码(各种循环处理、计算等),在这种情况下,由于计算工作多,ticks技术很快就会达到阀值,然后出发GIL的 释放与再竞争(多个线程来回切换当然是需要消耗资源的),所以python下的多线程对CPU密集型代码并不友好。
     
  2. IO密集型代码(文件处理、网络爬虫等设计文件读写操作),多线程能够有效提升效率(单线程下有IO操作会进行IO等待, 造成不必要的时间浪费,而开启多线程能在线程A等待时,自动切换到线程B,可以不浪费CPU的资源,从而能提升程序的执行 效率)。所以python的多线程对IO密集型代码比较友好
     
    主要要看任务的类型,我们把任务分为I/O密集型计算密集型,而多线程在切换中又分为I/O切换时间切换。如果任务属于是I/O密集型,若不采用多线程,我们在进行I/O操作时,势必要等待前面一个I/O任务完成后面的I/O任务才能进行,在这个等待的过程中,CPU处于等待状态,这时如果采用多线程的话,刚好可以切换到进行另一个I/O任务。这样就刚好可以充分利用CPU避免CPU处于闲置状态,提高效率。但是,如果多线程任务都是计算型,CPU会一直在进行工作,直到一定的时间后采取多线程时间切换的方式进行切换线程,此时CPU一直处于工作状态, 此种情况下并不能提高性能,相反在切换多线程任务时,可能还会造成时间资源的浪费,导致效能下降。这就是造成上面两种多线程结果不能的解释。
     

结论:I/O密集型任务,建议采取多线程,还可以采用多进程+协程的方式(例如:爬虫多采用多线程处理爬取的数据);对于计算密集型任务,python此时就不适用了。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/166199.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • cad图例大全_Dote图层

    cad图例大全_Dote图层之前总是想当然的认为,将N个纹理打包成一个图集,那么这个图集只会产生一个DrawCall,如果不打就产生N个DrawCall,后来才发现这并不是决定DrawCall的唯一因素,它还和层级关系有关······这里就会提到渲染的顺序问题,在渲染时默认会按照深度去渲染,也就是会先渲染离摄像机远的物体,后渲染离摄像机近的物体。例如你按顺序渲染三个物体A、B、C,A和C使用相同的材质1,B使用材质2,这…

  • RowBounds分页_bootstrap 分页

    RowBounds分页_bootstrap 分页只要给接口增加一个RowBounds传输就可以了。//下面测试MyBatis自带的分页类RowBounds功能publicList&lt;Role&gt;findByRowBounds(@Param("roleName")Stringrolename,@Param("note")Stringnote,RowBoundsrowBounds);而映射文件不需要任何…

  • VIM查找关键字方法「建议收藏」

    VIM查找关键字方法「建议收藏」单击“Ctrl”+”:”进入命令行模式打“/”+“关键字”回车就可以查找了上一个匹配:”N“,下一个匹配:”n”(next)

  • jetbrains 激活码【最新永久激活】

    (jetbrains 激活码)JetBrains旗下有多款编译器工具(如:IntelliJ、WebStorm、PyCharm等)在各编程领域几乎都占据了垄断地位。建立在开源IntelliJ平台之上,过去15年以来,JetBrains一直在不断发展和完善这个平台。这个平台可以针对您的开发工作流进行微调并且能够提供…

  • mysql添加索引造成的影响

    mysql添加索引造成的影响尽管添加索引可以优化SQL语句的性能,但是添加索引的同时也会带来不小的开销。尤其是在有大量的索引的情况下。mysql添加索引造成的影响如下:1、DML(数据操作语言)影响,在表上添加缩影会直接影响写操作性能(因为添加记录的同时还有创建相应记录的索引,这也是要耗资源的。)。2、DDL(数据定义语言)影响,随着表大小的不断增加,对性能的影响也会不断增加。比如:ALTER语句会耗费更多的时间…

  • python基础系列教程——Python的安装与测试:python解释器、PyDev编辑器、pycharm编译器

    python基础系列教程——Python的安装与测试:python解释器、PyDev编辑器、pycharm编译器全栈工程师开发手册(作者:陈玓玏)python教程全解白手起家,从头开启python的开发环境搭建。一.如何安装Python在https://www.python.org/下载安装包。下载下来一个exe文件,直接双击运行。选择InstallNow,立即安装。配置环境变量:右键开始——控制面板——系统——高级系统配置——环境变量。找…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号