python🏅多线程超细详解

时间  2021-08-14
标签 html 前端 python 编程 后端 markdown 多线程 并发 函数 oop 栏目 Python 繁體版
原文   原文链接

本文已参与好文召集令活动，点击查看：后端、大前端双赛道投稿，2万元奖池等你挑战！html

项目中多线程的目的

具体原理我以为这应该是能够跳到操做系统里面了一点点小小总结你们还能够找本操做系统的书看看，老规矩找不到的话找我主页，有一个关于资源的文章里面有资源固然也能够私信我。 咱们再说说咱们项目里面用多线程的目的： 1.线程之间共享内存很是容易。 2·使用多线程来实现多任务并发执行比使用多进程的效率高 3·有时候能够节省运行时间，这个一会在下面就会知道 4·当你一个文件要同时执行多个功能时就能够用到多线程前端

python语言内置了多线程功能支持，而不是单纯地做为底层操做系统的调度方式，从而简化了python的多线程编程。
复制代码

实战操做

说这么多不如实际动手练练，首先导入线程 特别注意 :你们在见建文件的时候名字千万别和导入的包threading同样否则会出错的。python

小知识

import threading
复制代码

让咱们先看看本身程序如今有多少个进程编程

import threading
def main():
    print(threading.current_thread())

if __name__ == '__main__':
    main()
复制代码
结果：1#个人就一个你的呢？
复制代码

若是你的进程不为一的话还能够这样查看每个进程名后端

import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
   

if __name__ == '__main__':
    main()
复制代码
>>>[<_MainThread(MainThread, started 36004)>]#返回的是一个列表由于个人目前就一个因此就一个主进程
复制代码

还能够查看正在运行的进程markdown

import threading
def main():
    print(threading.active_count())
    print(threading.enumerate())
    print(threading.current_thread())

if __name__ == '__main__':
    main()
复制代码
>1
[<_MainThread(MainThread, started 36004)>]
<_MainThread(MainThread, started 36004)>

复制代码

建立一个简单的线程

首先咱们先介绍一下threading.Thread（）里面的参数，你们学python每一个模块的功能时最好仍是看一下源文件内容，这样有助于提升你的编程能力： 在这里插入图片描述多线程

须要注意的点我已经打上标记了并发

import threading
def first():
    print("frist active")
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()#开始的标志
    print("main")

if __name__ == '__main__':
    main()
复制代码
结果：
第一次运行
frist active
main
frist finish
第二次运行
frist active
frist finish
main

复制代码

每次的结果不同就已经代表Frist和main是同时运行的了。 若是说效果不太明显的话，咱们改进一下接下来咱们引入函数

import time
复制代码
import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    first_thread.start()
    print("main")

if __name__ == '__main__':
    main()
复制代码
结果：
frist active
main
frist finish
复制代码

由于执行到Frist active的时候Frist线程要睡3秒这个时候main还在执行因此这样每次都是这个结果了。 特别强调target=first不是导入Frist函数从源文件咱们就已经看出是经过run（）方法进行的，这里解释我引用一位大佬解释 在这里插入图片描述oop

连接

这位大佬你们应该都熟悉，就是顶顶大名的雷学委各位大佬能够去他的主页看看可能会学到些新知识 固然若是你以为这样不行的话你也能够重写threading.Thresd里的run方法来个自定义线程

class MyThread(threading.Thread):
        def __init__(self,n):
            super(MyThread,self).__init__()   #重构run函数必须写
            self.n = n

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

    if __name__ == '__main__':
        t1 = MyThread('t1')
        t2 = MyThread('t2')
        t1.start()
        t2.start()
复制代码
结果：
task t1
task t2
2s
2s
1s
1s
0s
0s
复制代码

守护线程

所谓’线程守护’，就是主线程无论该线程的执行状况，只要是其余子线程结束且主线程执行完毕，主线程都会关闭。也就是说:主线程不等待该守护线程的执行完再去关闭。
复制代码

很差理解的话来看看例子

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.setDaemon(True)#必定要在start（）前开始
    first_thread.start()
    second_thresd.start()
    print("main")

if __name__ == '__main__':
    main()
    

复制代码
结果
frist active
second active
second finishjiemeijieshu
main

复制代码

当主线程和其余子线程都结束无论守护线程first_thread 结没结束程序都结束 当设second_thresd为守护线程的时候状况是这样的

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    second_thresd.setDaemon(True)#必定要在start（）前开始
    first_thread.start()
    second_thresd.start()
    print("main")

if __name__ == '__main__':
    main()
    


复制代码
frist active
second active
second finish
main
frist finish #尽管输出这个要等三秒
复制代码

主进程等待子进程结束

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

import threading
import time
def first():
    print("frist active")
    time.sleep(3)
    print("frist finish")

def second():
    print("second active")
    print("second finish")

def main():
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    first_thread.join()

    print("main")

if __name__ == '__main__':
    main()
    


复制代码
结果：
frist active
second active
second finish
frist finish
main
不加join是这样的结果
frist active
second active
second finish
main
frist finish
复制代码

共享全局变量的特性

这里定义一个全局变量A

import threading
import time
def first():
    global A
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist:%d"%A)
    print("frist finish")

def second():
    global A
    print("second active")
    A=A+6
    print("second:%d"%A)
    print("second finish")

def main():
    global A
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()




复制代码

来看一下结果

frist active
second active
second:6
second finish
main
mian:9
frist:12
frist finish
复制代码

锁

由上面的例子能够看出，输出A的值的时候不一样进程之间的资源是共享的这就致使了变量A的值不固定形成了脏数据的状况，不理解的话咱们就来个例子。 在这里插入图片描述

在没有互斥锁的状况下，假设帐户有一万元钱，存钱和取钱同时进行可能帐户余额会有一万一千元。这样我固然高兴只是银行不答应。为了不这种状况咱们引入锁的概念，下面咱们简单的介绍几种编程里面经常使用的。

互斥锁

import threading
import time
def first():
    global A,lock
    lock.acquire()
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist:%d"%A)
    print("frist finish")
    lock.release()

def second():
    global A,lock
    lock.acquire()
    print("second active")
    A=A+6
    print("second:%d"%A)
    print("second finish")
    lock.release

def main():
    global A,lock
    lock=threading.Lock()
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()

复制代码

结果

frist active
main
mian:3
frist:6
frist finish
second active
second:12
second finish

复制代码

是否是这样看着就舒服多了，若是例子不够明显咱们再来一个

import threading
import time
def first():
    global A,lock
    lock.acquire()
    print("frist active")
    time.sleep(3)
    A=A+3
    print("frist1:%d"%A)
    A = A + 3
    print("frist2:%d" % A)
    print("frist finish")
    lock.release()

def second():
    global A,lock
    lock.acquire()
    print("second active")
    A=A+6
    print("second1:%d"%A)
    A=A+6
    print("second2:%d"%A)

    print("second finish")
    lock.release()

def main():
    global A,lock
    lock=threading.Lock()
    first_thread=threading.Thread(target=first,name="T1")
    second_thresd=threading.Thread(target=second,name="T2")
    first_thread.start()
    second_thresd.start()
    #first_thread.join()

    print("main")
    A=A+3
    print("mian:%d"%A)

if __name__ == '__main__':
    A=0
    main()

复制代码

结果

frist active
main
mian:3
frist1:6
frist2:9
frist finish
second active
second1:15
second2:21
second finish

去掉锁之后结果

frist active
second active
second1:6
second2:12
second finish
main
mian:15
frist1:18
frist2:21
frist finish

复制代码

很明显去掉锁之后结果杂乱的很

信号量

我相信对操做系统有必定了解的确定，在刚才提到锁的时候就想到了信号量毕竟考研题常常会出现，同步，互斥和信号量机制。咱们就来讲一说信号量锁，其实道理很简单假如你如今，在中国结婚了你只能娶一个老婆吧，尽管你能够去找别的女人但他们不能称为老婆她们会被称为小三，二奶啊等等，这里老婆这个信号量在中国就是==一==只能有一个，别的再来就不能够了。

import threading
import time

def run(n,semaphore):
    semaphore.acquire()   #加锁
    time.sleep(3)
    print('run the thread:%s\n' % n)
    semaphore.release()    #释放


if __name__== '__main__':
    num=0
    semaphore = threading.BoundedSemaphore(3)   #最多容许3个线程同时运行
    for i in range(10):
        t = threading.Thread(target=run,args=('t-%s' % i,semaphore))
        t.start()
    while threading.active_count() !=1:
        pass
    else:
        print('----------all threads done-----------')

复制代码

结果

run the thread:t-2
run the thread:t-1


run the thread:t-0

run the thread:t-3
run the thread:t-5
run the thread:t-4



run the thread:t-6

run the thread:t-7

run the thread:t-8

run the thread:t-9

----------all threads done-----------

复制代码

送点资源

肥学以为python里面这些操做仍是有点简单的，若是各位大佬想继续深究线程又没有资源的话能够我这里有一本关于操做系统的书，领取能够私信我哦，好了今天的学习就到这里吧别忘了==点赞三联哦==

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程