Python 并发编程（线程）

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

Simple子夜

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

阅读量1.2k

点赞数 1

分类专栏： Python进阶文章标签： python 并发编程线程

本文链接：https://blog.csdn.net/m0_46958731/article/details/112966806

版权

Python进阶专栏收录该内容

19 篇文章 4 订阅

订阅专栏

线程

线程：执行单位,cpu执行的就是线程，一个流水线的运行过程（进程内代码的运行过程）

进程：资源单位，会申请一块内存空间来存放程序，进程是包含线程的一个容器

执行一个Python文件默认会开启一个进程，进程内默认包含一个线程（主线程），相当于执行每个操作都是由一个线程来执行的，而我们开启的子进程其中也包含一个线程，所以它占用的资源会远大于创建一个线程。多线程就是在一个进程内开启多个线程。

线程的优势

同一进程下的多个线程共享该进程的内存空间。
开启子线程的开销远小于开启子进程

线程与进程的区别

1、线程共享创建它的进程的地址空间；进程有自己的地址空间。
2、线程可以直接访问其进程的数据段；进程有自己的父进程数据段副本。
3、线程可以直接与其进程的其他线程通信；进程必须使用进程间通信来与同级进程通信。
4、新线程很容易创建；新进程需要复制父进程。
5、线程可以对同一进程的线程执行相当大的控制；进程只能对子进程执行控制。
6、对主线程的更改（取消、优先级更改等）可能会影响进程的其他线程的行为；对父进程的更改不会影响子进程。

多线程的开启

Python使用threading模块来创建线程，但是其实还有另一种模块_thread也可以创建线程，但基本被淘汰了，其功能远不如threading，所以这里使用的是teahding模块

import threading
import time


def task(n):
    print('当前线程：%s 开始了' % threading.currentThread().name)
    time.sleep(n)
    print('当前线程：%s 结束了' % threading.currentThread().name)
    
	# threading.currentThread() 执行这个函数的线程对象
	# .name这个线程的名称

if __name__ == '__main__':
    t = threading.Thread(target=task, args=(1,))
    t2 = threading.Thread(target=task, args=(2,))

    t.start()
    t2.start()

    t.join()
    t2.join()

    print('主线程结束了',threading.currentThread().name) # 主线程名称

执行结果

'''
当前线程：Thread-1 开始了
当前线程：Thread-2 开始了
当前线程：Thread-1 结束了
当前线程：Thread-2 结束了
主线程结束了 MainThread
'''

创建使用线程的方式与进程大部分都相似

创建、并开启一个子线程的速度远快于一个子进程

import threading

def task():
    print(f'线程：{threading.currentThread().name} 开启')

if __name__ == '__main__':
    t = threading.Thread(target=task)
    t.start()

    print(' 主线程结束了') # 开启线程速度很快，呈现出来的效果几乎会优先这行显示出来

执行结果

'线程：Thread-1 开启 主线程结束了'

以上叙述了一种开启线程的方式，第二种就是通过继承的方式来开启线程

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,count):
        super().__init__()
        self.count = count

    def run(self) -> None:
        print(f'Thread-{self.count}开启了')
        time.sleep(self.count)
        print(f'Thread-{self.count}结束了')

if __name__ == '__main__':
    t = MyThread(1)
    t.start()
    t.join() # 主线程等待子线程结束
    
    print('主线程结束了')

线程对象的常用方法

通过提供的方法，我们可以查看当前进程内线程的状态信息

import threading

threading.currentThread() # 获取当前线程对象
# threading.current_thread() 效果一样

print(threading.currentThread().name) # 获取线程的名称

print(threading.currentThread().is_alive()) # 获取这个线程是否存活

print(threading.active_count()) # 当前进程活跃线程的数量

print(threading.enumerate()) # 当前进程内所有活跃的线程，返回一个列表

print(threading.get_ident()) # 获取当前线程编号

守护线程

当某个线程成为守护线程，它首要关注的是主线程的生命周期，如果主线程生命周期结束，不管这个守护线程是否正在运行，都会随之结束。

守护线程与守护进程不同的是：

守护进程关注的是：父进程的代码是否执行完毕。
守护线程关注的是：当前程序的任务是否执行完毕，但不包括守护线程。

import threading
import time

# 守护线程：守护的是主线程的生命周期
def task(n):
    print(f' 子线程：{threading.current_thread().name} 开启了') # 获取线程名称
    time.sleep(n)
    print(f' 子线程：{threading.current_thread().name} 结束了')

if __name__ == '__main__':
    t = threading.Thread(target=task,args=(10,))
    t.daemon = True # 将t变成守护线程

    t2 = threading.Thread(target=task,args=(5,))

    t.start()
    t2.start()
    # 当前程序，当这个线程运行完以后，整体主线程就会结束，那么不管t线程是否运行完毕，都会结束

    # 主线程会等待所有子线程结束，生命周期才会结束，但是不包括守护线程。
    # 也就是说主线程会等待其它的线程，而不会等待守护线程，当其它线程结束以后，主线程就会结束，并且会携带守护线程一起离去

执行结果

'''
 子线程：Thread-1 开启了
 子线程：Thread-2 开启了
 子线程：Thread-2 结束了
 '''

但也有情况就是，主线程等待其它线程运行过程中，守护线程运行完毕了

注意：不要给守护线程添加join方法，因为这样就会失去守护线程应有的效果

import threading
import time

# 守护线程：守护的是主线程的生命周期
def task(n):
    print(f' 子线程：{threading.current_thread().name} 开启了') # 获取线程名称
    time.sleep(n)
    print(f' 子线程：{threading.current_thread().name} 结束了')

if __name__ == '__main__':
    t = threading.Thread(target=task,args=(10,))
    t.daemon = True # 将t变成守护线程

    t2 = threading.Thread(target=task,args=(5,))

    t.start()
    t2.start()

    t.join()

给守护线程添加join后，主线程也会等待这个守护线程执行完毕，此时它就成了一个普通的线程

'''
 子线程：Thread-1 开启了
 子线程：Thread-2 开启了
 子线程：Thread-2 结束了
 子线程：Thread-1 结束了
 '''

线程之间内存共享

相同进程下的线程之间的数据是共享的，如果相同进程下的多线程需要通信，可以在主线程定义一个共享变量、或队列来实现信息互通，而不同进程下的线程如果需要通信，则只能通过队列、管道等等

import threading
import time

count = 100

def task():
    global count
    print(f'子线程：{threading.currentThread().name}',count)
    count += 1 # 修改主线程内的count变量值

if __name__ == '__main__':
    start = time.time()
    t = threading.Thread(target=task)

    t.start()
    t.join()

    print(f'主线程：{threading.currentThread().name}',count)

执行结果

'''
子线程：Thread-1 100
主线程：MainThread 101
'''

如果使用过进程执行该操作就会知道，子进程是将父进程内的名称空间完整拷贝一份，进行的操作不会影响到父进程。而线程则是直接可以访问主线程数据及修改操作，不需要拷贝。

互斥锁

在多个线程修改某个共享数据时，如果要确保数据的安全性，那么就需要进行线程同步了。线程同步可以保证多个线程安全访问数据，这样也会避免同一时间操作相同数据造成的错乱，引入互斥锁是很好的选择。

未加锁前，修改同一数据，不妨猜测一下执行结果

import threading
import time

count = 0

lock = threading.Lock()

def task():
    global count

    for i in range(100000):
        count += 1

if __name__ == '__main__':
    thread = []
    start = time.time()

    for i in range(10):
        t = threading.Thread(target=task)
        t.start()
        thread.append(t)

    for i in thread:
        i.join()

    print(time.time() - start)

    print(f'主线程：{threading.currentThread().name}',count)

执行结果

'''
0.10023021697998047
主线程：MainThread 871675
'''

造成这种结果的原因是：本质上每个线程会给这个count增加10000，有可能在某一次多个线程同时进行了+=1的操作，时间完全相同，那么此时这个count只会+1，从而导致多次这样，导致数据已经错乱。

ps：但是也有可能数值是准确的，那么我们可以再把for循环次数调高一些

而如果我们要以这种方式将count变为理想数字的话，需要使用互斥锁来对每个线程的操作进行锁定，待执行完以后再进行释放。

import threading
import time

count = 0

lock = threading.Lock()

def task():
    global count
    lock.acquire()

    for i in range(100000):
        count += 1

    lock.release()

if __name__ == '__main__':
    thread = []
    start = time.time()

    for i in range(10):
        t = threading.Thread(target=task)
        t.start()
        thread.append(t)

    for i in thread:
        i.join()

    print(time.time() - start)

    print(f'主线程：{threading.currentThread().name}',count)

执行结果

'''
0.09698486328125
主线程：MainThread 1000000
'''

当每次线程执行完操作以后，下一个线程才能执行，这就变成的串行执行，但是数据达到了保证，不会出现错乱。

信号量

可以理解为锁，但是信号量可以指定锁的数量，可以根据信号量值来进行锁定。

from threading import Thread,Semaphore,currentThread
import time
import random

def func():
    sm.acquire()
    print(f'{currentThread().name} 正在运行')
    time.sleep(random.randint(1,3))
    print(f'{currentThread().name} 运行完毕')
    sm.release()

    # 当5信号量被5个线程使用后，其它线程只能等待其中某个释放，才能执行

if __name__ == '__main__':
    sm = Semaphore(5) # 指定信号量值

    for i in range(15):
        t = Thread(target=func)
        t.start()

信号量与互斥锁的区别：

1、互斥量用于线程的互斥，信号量用于线程的同步。这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。
/
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
/
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。

死锁/递归锁

造成死锁的原因是：线程获取锁时无法获取到，那么程序就会一直阻塞在原地，且不会报错，给我们造成的错觉就是程序还在运行中。

代码演示死锁情况：

from threading import Thread,Lock,RLock,currentThread
import time

# 创建两个锁
lockA = Lock()
lockB = Lock()
class MyThread(Thread):
    def run(self) -> None:
        self.f1()
        self.f2()

    def f1(self):
        lockA.acquire()
        print(f'{self.name} 抢到A锁')

        lockB.acquire()
        print(f'{self.name} 抢到B锁')

        lockB.release()

        lockA.release()

    def f2(self):
        lockB.acquire()
        print(f'{self.name} 抢到B锁')

        time.sleep(0.1)
        
        lockA.acquire()
        print(f'{self.name} 抢到A锁')

        lockA.release()

        lockB.release()

if __name__ == '__main__':
    for i in range(4): # 启动4个线程
        t = MyThread()
        t.start()

执行结果

'''
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-2 抢到A锁
'''

分析：

当线程1执行f1函数时，由于它启动速度够快首先就拿到了A锁，那么此时其它线程开启后只能等待它把A锁释放掉，当线程1执行到f2后，已经将A锁释放了，所有线程就可以竞争拿到A锁，然后线程1执行f2函数拿到B锁，线程1手里拿到B锁进入睡眠0.1s的过程中，线程2已经把A锁抢到了，而此时线程2又想获取B锁，当线程1睡眠结束想获取A锁时，却发现A锁正在被使用，所以它们都在等对方释放锁，所以就会出现死锁现象。

如果出现这种锁套锁的写法，我们为了避免出现死锁，通常使用递归锁来解决问题

递归锁可以进行多次acquire()，每次锁定都会计数+1，每次释放都会计数-1，当其它线程想要获取锁时，首先会检测计数是否为0，如果为0则可以获取。

from threading import Thread,RLock
import time

lockA = lockB = RLock() # 链式赋值，lockA和lockB是同一个锁

class MyThread(Thread):
    def run(self) -> None:
        self.f1()
        self.f2()

    def f1(self):
        lockA.acquire()
        print(f'{self.name} 抢到A锁')

        lockB.acquire()
        print(f'{self.name} 抢到B锁')

        lockB.release()

        lockA.release()

    def f2(self):
        lockB.acquire()
        print(f'{self.name} 抢到B锁')

        time.sleep(0.1)
        
        lockA.acquire()
        print(f'{self.name} 抢到A锁')

        lockA.release()

        lockB.release()

if __name__ == '__main__':
    for i in range(4):
        t = MyThread()
        t.start()

执行结果

'''
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-1 抢到A锁
Thread-3 抢到A锁
Thread-3 抢到B锁
Thread-3 抢到B锁
Thread-3 抢到A锁
Thread-4 抢到A锁
Thread-4 抢到B锁
Thread-4 抢到B锁
Thread-4 抢到A锁
Thread-2 抢到A锁
Thread-2 抢到B锁
Thread-2 抢到B锁
Thread-2 抢到A锁
'''

注意：lockA和lockB是同一个锁，当lockB被某个线程拿到后，锁的计数就会加1，所以其它线程都不能拿到锁。

分析：

当线程1开启后执行了f1函数，此时其它线程都在等待线程1执行完该函数把锁释放掉，但是线程1执行完f1函数后，很快啊，又执行到了f2函数，又拿到了锁，所以呈现给我们的就是这么整齐的效果。（ps：也有可能是笔者电脑的原因，有可能的效果就是线程1执行完f1函数后，准备执行f2函数，同时其它线程执行了f1函数，拿到了锁，然后开始操作。）

事件Event

通过threading.Event()可以创建一个事件管理标志，该标志Event()默认为False。

它具备4个常用方法：

event.wait(timeout=None)：调用该方法的线程会被阻塞，如果设置了timeout参数，超时后，线程会停止阻塞继续执行
event.set()：将event的标志设置为True，调用wait方法的所有线程将被唤醒
event.clear()：将event的标志设置为False，调用wait方法的所有线程将被阻塞
event.isSet()：判断event的标志是否为True，ps：event.is_set()效果相同

代码示例：

from threading import Thread,Event,currentThread
import time

e = Event() # 创建一个事件标识，默认为False

def f1():
    print(f'{currentThread().name} 正在运行')
    time.sleep(3)

    print(f'{currentThread().name} 运行结束')

    e.set() # 将e事件设置为True

def f2():
    e.wait() # 如果e事件不为True则进入阻塞
    print(f'{currentThread().name} 正在运行')
    e.clear() # 将这个事件变成False

if __name__ == '__main__':
    t = Thread(target=f1)
    t2 = Thread(target=f2)

    t.start()
    t2.start()

执行结果

'''
Thread-1 正在运行
Thread-1 运行结束
Thread-2 正在运行
'''

这里相当于两个线程都用于这个事件，第二个线程必须阻塞等待这个事件变为True，所以需要等待第一个线程再执行完，将这个事件变为True，第二个线程才可以运行，第二个线程运行完毕就可以再次将这个事件还原为False

模拟红绿灯（不包括黄灯）

from threading import Thread,Event
import time
from faker import Faker # 创建伪数据
import random

e = Event()

def traffic_lights():
    while True:
        e.clear()
        print('红灯亮')
        time.sleep(2)

        e.set()
        print('绿灯亮')
        time.sleep(3)

def pedestrian():
    faker = Faker(locale='en_AU') # 创建Australia地区的假数据
    name = faker.name() # 获取这个地区的名称数据
    while True:
        if e.is_set():
            print(f'{name} 走过去了')
            break
        else:
            print(f'{name} 等待绿灯')
            e.wait()

if __name__ == '__main__':
    Thread(target=traffic_lights).start() # 先将红绿灯开启

    while True: # 不断创建行人
        time.sleep(random.randint(1,3)) # 1-3s 来一个行人
        Thread(target=pedestrian).start()

执行结果

'''
红灯亮
绿灯亮
Cheryl Butler 走过去了
Ralph Perry 走过去了
红灯亮
Mr. David Austin PhD 等待绿灯
绿灯亮
Mr. David Austin PhD 走过去了
Kim Reed 走过去了
........
'''

pedestrian函数会根据traffic_lights函数改变Event标志来行动

队列queue

queue模块实现了生产者、消费者队列（详见可以去了解笔者的进程篇）当信息必须安全的在多线程之间交换时，该模块可以很好的作为中间的桥梁。

该模块主要实现了三种类型的队列：

FIFO：先进先出（队列）
LIFO：后进先出（堆栈）
Priority：优先级队列

1、FIFO队列

import queue

# 队列：先进先出
q = queue.Queue() # 括号内加入数字，表示指定可入队数量，不添加则无上限

# 入队
q.put(1)
q.put(2)
q.put(3)

# 出队
print(q.get()) # 1
print(q.get()) # 2
print(q.get()) # 2
print(q.get()) # 当队列为空时，get就会进入阻塞状态。

print(q.get(block=False)) # block=False表示队列满了，则直接报错
q.get(timeout=3) # timeout=3表示：3s内如果没有get到数据，则报错

2、LIFO堆栈

q = queue.LifoQueue()

q.put(1)
q.put(2)
q.put(3)

print(q.get()) # 3
print(q.get()) # 2
print(q.get()) # 1

3、优先级队列

# 优先级队列，入队时需要设置数字代表优先级，数字越低，优先级越高，以元组形式入队
q = queue.PriorityQueue()

# 第一个参数必须是数字，代表优先级
q.put((10,'元素1'))
q.put((20,'元素2'))
q.put((-10,'元素3'))
q.put((-15,'元素4'))

# 按优先级从高到低出队
print(q.get()) # (-15, '元素4')
print(q.get()) # (-10, '元素3')
print(q.get()) # (10, '元素1')
print(q.get()) # (20, '元素2')

常用方法（三种类型通用）：

q = queue.Queue(3)
print(q.empty()) # 当队列为空，返回True，不为空则返回False
# True

print(q.full()) # 队列满了，返回True，否则返回False
# False

q.put() # 入队
q.get() # 出队

q.task_done() # 通常在q.get()后使用，它主要向队列发送信号，已取出一个数据
q.join() # 阻塞当前线程。如果q.task_done发出信号的次数，与put入队的次数相同，则取消阻塞

print(q.maxsize) # 可入队个数，如果未指定，则为0
# 3

定时器

Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。

语法

from threading import Timer
Timer(interval, function, args=None, kwargs=None):

interval：指定时间
function：需要执行的方法
args | kwargs：向指定方法传递的参数

实例

def index():
    print(f'My name is ')

timer = Timer(3,index) # 无参数传递
timer.start()

def index(name):
    print(f'My name is {name}')

timer = Timer(3,index,('jack',)) # 位置传参
timer.start()

def index(name):
    print(f'My name is {name}')

timer = Timer(3,index,{'name':'jack'}) # 关键字传参
timer.start()

本质上就是：达到指定时间后，开启一条线程来执行。

GIL全局解释器锁

https://blog.csdn.net/m0_46958731/article/details/113002518

线程池

看过笔者进程篇里面的进程池，再来使用这个线程池，就会发现使用方式几乎完全相同

我们可以指定线程并发的数量，异步调用

from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import time

def task(i):
    print(f'{currentThread().name} 正在运行{i}')
    time.sleep(2)
    print(f'{currentThread().name} 运行结束{i}\n')

    return i

def handle(future):
    future = future.result() # 拿到线程对象执行任务的结果
    print(f'{currentThread().name} 处理结果{future}')

if __name__ == '__main__':

    t = ThreadPoolExecutor(10)

    for i in range(20):
        t.submit(task,i).add_done_callback(handle)
        # 将执行任务的线程对象，回调给handle函数

执行结果

'''
ThreadPoolExecutor-0_0 正在运行0ThreadPoolExecutor-0_1 正在运行1

ThreadPoolExecutor-0_2 正在运行2
ThreadPoolExecutor-0_3 正在运行3
ThreadPoolExecutor-0_4 正在运行4
ThreadPoolExecutor-0_5 正在运行5
ThreadPoolExecutor-0_6 正在运行6
ThreadPoolExecutor-0_7 正在运行7
ThreadPoolExecutor-0_8 正在运行8
ThreadPoolExecutor-0_9 正在运行9
ThreadPoolExecutor-0_1 运行结束1
ThreadPoolExecutor-0_4 运行结束4

ThreadPoolExecutor-0_4 处理结果4
ThreadPoolExecutor-0_2 运行结束2

ThreadPoolExecutor-0_0 运行结束0

ThreadPoolExecutor-0_7 运行结束7

ThreadPoolExecutor-0_7 处理结果7

ThreadPoolExecutor-0_0 处理结果0
ThreadPoolExecutor-0_5 运行结束5

ThreadPoolExecutor-0_5 处理结果5
ThreadPoolExecutor-0_8 运行结束8

ThreadPoolExecutor-0_8 处理结果8
ThreadPoolExecutor-0_2 处理结果2
ThreadPoolExecutor-0_6 运行结束6

ThreadPoolExecutor-0_6 处理结果6
ThreadPoolExecutor-0_3 运行结束3

ThreadPoolExecutor-0_3 处理结果3
ThreadPoolExecutor-0_1 处理结果1
ThreadPoolExecutor-0_9 运行结束9

ThreadPoolExecutor-0_9 处理结果9
'''

map方法：取代了我们for循环submit的用法

from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import time

def task(i):
    print(f'{currentThread().name} 正在运行{i}')
    time.sleep(2)
    print(f'{currentThread().name} 运行结束{i}\n')

    return i


if __name__ == '__main__':

    t = ThreadPoolExecutor(10)
    lis = [
        'Hello',
        'World',
        'Nihao',
        'Python'
    ]
    t.map(task,lis) # (函数，传递的参数)

    t.shutdown(wait=True)

执行结果

'''
ThreadPoolExecutor-0_0 正在运行Hello
ThreadPoolExecutor-0_1 正在运行World
ThreadPoolExecutor-0_2 正在运行Nihao
ThreadPoolExecutor-0_3 正在运行Python
ThreadPoolExecutor-0_0 运行结束Hello

ThreadPoolExecutor-0_3 运行结束Python

ThreadPoolExecutor-0_1 运行结束World

ThreadPoolExecutor-0_2 运行结束Nihao
'''

技术小白记录学习过程，有错误或不解的地方请指出，如果这篇文章对你有所帮助请点赞收藏+关注 子夜期待您的关注，谢谢支持！

Simple子夜

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python 并发编程（线程）

多线程线程：执行单位,cpu执行的就是线程，一个流水线的运行过程（进程内代码的运行过程）进程：资源单位，会申请一块内存空间来存放程序，进程是线程包含线程的一个容器执行一个Python文件默认会开启一个进程，进程内默认包含一个线程（主线程），相当于执行每个操作都是由一个线程来执行的，而我们开启的子进程其中也包含一个线程，所以它占用的资源会远大于创建一个线程。多线程就是在一个进程内开启多个线程。线程与进程同一进程下的多个线程共享该进程的内存空间。开启子线程的开销远小于开启子进程多线程的
复制链接

扫一扫