mofan-python多线程Threading

最新推荐文章于 2024-09-11 20:54:14 发布

知之之之

最新推荐文章于 2024-09-11 20:54:14 发布

阅读量168

点赞数

分类专栏： mofanpy-莫烦python学习笔记文章标签： python 多线程

本文链接：https://blog.csdn.net/qq_39330170/article/details/112311481

版权

mofanpy-莫烦python学习笔记专栏收录该内容

7 篇文章 11 订阅

订阅专栏

本文详细介绍了Python的多线程概念，包括线程的创建与使用，通过实例展示了`join`功能如何控制线程执行顺序。接着，文章探讨了Python多线程效率受限于全局解释器锁（GIL），并提供了一个使用`Queue`存储线程结果的例子。最后，通过线程锁`Lock`解决了线程间共享资源的问题，保证了线程安全。

摘要由CSDN通过智能技术生成

1、什么是多线程

在一个程序运行过程中，能够在同一时刻运行多个不同的操作。

单线程—>串行
多线程—>并行

多线程是加速程序计算的有效方式，Python的多线程模块threading上手快速简单，从这节开始我们就教大家如何使用它。

2、添加线程Thread

import threading  #导入模块

print(threading.active_count())  # 获取已激活的线程数
print(threading.enumerate()) # 查看所有线程信息
print(threading.current_thread()) # 查看现在正在运行的线程

def thread_job():  # 这个线程要完成的任务
    print('This is a thread of %s' % threading.current_thread())

def main():
    thread = threading.Thread(target=thread_job,)  # 添加线程，接受任务
    thread.start()  # 线程开始工作
if __name__ == '__main__':
    main()

5
[<_MainThread(MainThread, started 18968)>, <Thread(Thread-4, started daemon 6296)>, <Heartbeat(Thread-5, started daemon 5824)>, <HistorySavingThread(IPythonHistorySavingThread, started 16816)>, <ParentPollerWindows(Thread-3, started daemon 6624)>]
<_MainThread(MainThread, started 18968)>
This is a thread of <Thread(Thread-6, started 18268)>

3、join功能

import threading
import time
def thread_job():  # 让 T1 线程工作的耗时增加.
    print('T1 start\n')
    for i in range(10):
        time.sleep(0.1)  # 任务间隔0.1s
    print('T1 finish\n')
    
added_thread = threading.Thread(target=thread_job, name='T1')
added_thread.start()
print("all done\n")

T1 start

all done

为什么先输出all done，再输出T1 finish呢？
——使用join控制多个线程的执行顺序

import threading
import time
def thread_job():  # 让 T1 线程工作的耗时增加.
    print('T1 start\n')
    for i in range(10):
        time.sleep(0.1)  # 任务间隔0.1s
    print('T1 finish\n')
    
added_thread = threading.Thread(target=thread_job, name='T1')
added_thread.start()
added_thread.join()  # 使用join来控制多个线程的执行顺序
print("all done\n")

T1 start

T1 finish

T1 finish

all done

join的重要性
假设我们现在再加一个线程T2，T2的任务量较小，会比T1更快完成：all done的出现完全取决于两个线程的执行速度，有可能finish出现在all done之后。这种杂乱的执行方式是我们不能忍受的，因此要使用join加以控制。

def T1_job():
    print("T1 start\n")
    for i in range(10):
        time.sleep(0.1)
    print("T1 finish\n")

def T2_job():
    print("T2 start\n")
    print("T2 finish\n")

thread_1 = threading.Thread(target=T1_job, name='T1')
thread_2 = threading.Thread(target=T2_job, name='T2')
thread_1.start() # 开启T1
thread_2.start() # 开启T2
print("all done\n")

T1 start
T2 start

T2 finish


all done

情况一：在T1启动后，T2启动前加上thread_1.join():T2会等待T1结束后才开始运行，但all done会在T2完成前就出现。

thread_1 = threading.Thread(target=T1_job, name='T1')
thread_2 = threading.Thread(target=T2_job, name='T2')
thread_1.start()
thread_1.join() # notice the difference!
thread_2.start()
print("all done\n")

T1 start

T1 finish

T1 finish

T2 start
all done


T2 finish

情况二：T2启动后放上thread_1.join()：T2在T1之后启动，并且因为T2任务量小会在T1之前完成；而T1因为加了join，all done在它完成后才显示。

thread_1 = threading.Thread(target=T1_job, name='T1')
thread_2 = threading.Thread(target=T2_job, name='T2')
thread_1.start()
thread_2.start()
thread_1.join() # notice the difference!
print("all done\n")

T1 start

T2 start

T2 finish

T1 finish

all done

推荐：

thread_1 = threading.Thread(target=T1_job, name='T1')
thread_2 = threading.Thread(target=T2_job, name='T2')
thread_1.start() # start T1
thread_2.start() # start T2
thread_2.join() # join for T2
thread_1.join() # join for T1
print("all done\n")

T1 start

T2 start

T2 finish

T1 finish

all done

4、储存进程结果 Queue

# 导入线程、队列的标准模块
import threading
import time
from queue import Queue

# 定义一个被多线程调用的函数
# 函数的参数是一个列表l和一个队列q，函数的功能是，对列表的每个元素进行平方计算，将结果保存在队列中
def job(l,q):
    for i in range (len(l)):
        l[i] = l[i]**2
    q.put(l)  #多线程调用的函数不能用return返回值！！！

# 定义一个多线程函数 
def multithreading():
    q =Queue() #q中存放返回值，代替return的返回值
    threads = []
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    # 在多线程函数中定义四个线程，启动线程，将每个线程添加到多线程的列表中
    for i in range(4): #定义四个线程
        t = threading.Thread(target=job,args=(data[i],q)) #Thread首字母要大写，被调用的job函数没有括号，只是一个索引，参数在后面
        t.start() # 开始线程
        threads.append(t) #把每个线程append到线程列表中
    for thread in threads:  # 分别join四个线程到主线程
        thread.join()
    results = [] # 定义一个空的列表results，将四个线运行后保存在队列中的结果返回给空列表results
    for _ in range(4):
        results.append(q.get()) #q.get()按顺序从q中拿出一个值
    print(results)

if __name__ == '__main__':
    multithreading()

[[1, 4, 9], [9, 16, 25], [16, 16, 16], [25, 25, 25]]

5、不一定有效率

这次我们来看看为什么说 python 的多线程 threading 有时候并不是特别理想. 最主要的原因是就是, Python 的设计上, 有一个必要的环节, 就是 Global Interpreter Lock (GIL). 这个东西让 Python 还是一次性只能处理一个东西.

关于GIL
- 尽管Python完全支持多线程编程，但是解释器的C语言实现部分在完全并行执行时并不是线程安全的。实际上，解释器被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。 GIL最大的问题就是Python的多线程程序并不能利用多核CPU的优势（比如一个使用了多个线程的计算密集型程序只会在一个单CPU上面运行）。
- 在讨论普通的GIL之前，有一点要强调的是GIL只会影响到那些严重依赖CPU的程序（比如计算型的）。如果你的程序大部分只会涉及到I/O，比如网络交互，那么使用多线程就很合适，因为它们大部分时间都在等待。实际上，你完全可以放心的创建几千个Python线程，现代操作系统运行这么多线程没有任何压力，没啥可担心的。
测试GIL

import threading
from queue import Queue
import copy
import time

def job(l, q):
    res = sum(l)
    q.put(res)

def multithreading(l):
    q = Queue()
    threads = []
    for i in range(4):
        t = threading.Thread(target=job, args=(copy.copy(l), q), name='T%i' % i)
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total = 0
    for _ in range(4):
        total += q.get()
    print(total)

def normal(l):
    total = sum(l)
    print(total)

if __name__ == '__main__':
    l = list(range(1000000))
    s_t = time.time()
    normal(l*4)
    print('normal: ',time.time()-s_t)
    s_t = time.time()
    multithreading(l)
    print('multithreading: ', time.time()-s_t)

1999998000000
normal:  0.17253494262695312
1999998000000
multithreading:  0.1625659465789795

threading 却没有快多少, 按理来说, 我们预期会要快3-4倍, 因为有建立4个线程, 但是并没有. 这就是其中的 GIL 在作怪.

6、线程锁Lock

import threading

# 函数一：全局变量A的值每次加1，循环10次，并打印
def job1():
    global A
    for i in range(10):
        A+=1
        print('job1',A)

# 函数二：全局变量A的值每次加10，循环10次，并打印
def job2():
    global A
    for i in range(10):
        A+=10
        print('job2',A)

# 主函数：定义两个线程，分别执行函数一和函数二
if __name__== '__main__':
    A=0
    t1=threading.Thread(target=job1)
    t2=threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 job2 20
job210
 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110

打印的非常混乱，加个Lock试试

Lock在不同线程使用同一共享内存时，能够确保线程之间互不影响，使用lock的方法是，在每个线程执行运算修改共享内存之前，执行lock.acquire()将共享内存上锁，确保当前线程执行时，内存不会被其他线程访问，执行运算完毕后，使用lock.release()将锁打开，保证其他的线程可以使用该共享内存。

def job1():
    global A,lock
    lock.acquire() #  !!!
    for i in range(10):
        A+=1
        print('job1',A)
    lock.release() #  !!!

def job2():
    global A,lock
    lock.acquire() #  !!!
    for i in range(10):
        A+=10
        print('job2',A)
    lock.release() #  !!!

if __name__== '__main__':
    lock=threading.Lock()  #  !!!
    A=0
    t1=threading.Thread(target=job1)
    t2=threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110

使用lock后，一个一个线程执行完。