python多线程实现原理_Python多线程原理与用法详解

最新推荐文章于 2024-03-28 14:05:33 发布

weixin_39824191

最新推荐文章于 2024-03-28 14:05:33 发布

阅读量131

点赞数

文章标签： python多线程实现原理

本文实例讲述了python多线程原理与用法。分享给大家供大家参考，具体如下：

多线程(英语：multithreading)，是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理(chip-level multithreading)或同时多线程(simultaneous multithreading)处理器。[1] 在一个程序中，这些独立运行的程序片段叫作“线程”(thread)，利用它编程的概念就叫作“多线程处理(multithreading)”。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程(台湾译作“执行绪”)，进而提升整体处理性能。

创建并启动一个线程

import threading

def runtask(name):

print("%s线程已启动"%name)

t = threading.thread(target=runtask,args=("task1",)) # args因为是一个元组，所以必须这样写,否则运行将报错

t.start()

join

等待当前线程执行完毕

import threading

import time

def runtask(name):

print("%s线程已启动"%name)

time.sleep(2)

t = threading.thread(target=runtask,args=("task1",))

t.start()

t.join()

print("abc") # 过了2s才会打印，若无等待将看不到等待2s的效果

setdaemon(true)

将线程设置为守护线程。若设置为守护线程，主线程结束后，子线程也将结束，并且主线程不会理会子线程是否结束，主线程不会等待子线程结束完后才结束。若没有设置为守护线程，主线程会等待子线程结束后才会结束。

active_count

程序的线程数量，数量=主线程+子线程数量

lock(互斥锁)

python编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为” 互斥锁” 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。在python中我们使用threading模块提供的lock类。

import threading,time

def runtask(name):

global count

time.sleep(1)

lock.acquire() # 获取锁资源，并返回是否获取成功

count+=1

print(name,count)

lock.release() # 释放资源

count = 0

lock = threading.lock() # 互斥锁

for index in range(50):

t = threading.thread(target=runtask,args=("thread%d"%index,))

t.start()

上面这段代码如果没有加上互斥锁，在python2.x中执行的结果将会是乱的。在python3.x中执行却总是正确的，似乎是自动为其加了锁

rlock(递归锁，可重入锁)

当一个线程中遇到锁嵌套情况该怎么办，又会遇到什么情况？

def run1():

global count1

lock.acquire()

count1 += 1

lock.release()

return count1

def run2():

global count2

lock.acquire()

count2 += 1

lock.release()

return count2

def runtask():

lock.acquire()

r1 = run1()

print("="*30)

r2 = run2()

lock.release()

print(r1,r2)

count1,count2 = 0,0

lock = threading.lock()

for index in range(50):

t = threading.thread(target=runtask,)

t.start()

这是一个很简单的线程锁死案例，程序将被卡死，停止不动。为了解决这一情况，python提供了递归锁rlock(可重入锁)。这个rlock内部维护着一个lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的代码只需做一些小小的改动

lock = threading.lock()

修改为:

lock = threading.rlock()

那么程序将不会发生死锁情况。

最大可执行线程

threading.boundedsemaphore(5)设置可同时执行的最大线程数为5个，后面的线程需排队等待前面的线程执行完毕

import time,threading

def runtask(name):

global num

semaphore.acquire()

time.sleep(1)

num += 1