Python的多线程

已于 2023-10-14 18:47:14 修改
阅读量227 收藏
点赞数
分类专栏： python 文章标签： python linux 开发语言
于 2023-10-12 23:22:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41304832/article/details/133800285
版权

目录

两种方法实现多线程

Semaphore

Condition

Event（wait、set、clear）

Queue

Pool

Pipe

需要导入threading库中Thread类，例如 from threading import Thread

两种方法实现多线程

1、类继承Thread父类，并重写init方法（初始化需要接收的一些属性），run方法（里面编写多线程的业务逻辑），例如：

class MyThread(Thread):

    def __init__(self, num):
        self.num = num
        super().__init__()

    def run(self):
        count = self.num
        while count:
            print(f"{time.strftime('%H:%M:%S')} {threading.current_thread().name} 计数{count} ")
            time.sleep(2)
            count -= 1

2、不继承父类Thread，直接通过Thread类提供的初始化实例方法接收参数

def threading_task(num):
    count = num
    while count:
        print(f"{time.strftime('%H:%M:%S')} {threading.current_thread().name} 计数{count} ")
        time.sleep(2)
        count -= 1


my_thread1 = threading.Thread(target=threading_task, args=(3,), name='my_thread1')
my_thread2 = threading.Thread(target=threading_task, args=(2,), name='my_thread2')

3、选择上面任意一种方式生成thread的实例，调用start方法启动多线程 thread.start()

比如用上面1的实现方法调试：

if __name__ == "__main__":
    print(f"{time.strftime('%H:%M:%S')} 主进程开始")
    my_thread1 = MyThread(3)
    my_thread2 = MyThread(2)
    my_thread1.name = 'my_thread1'
    my_thread2.name = 'my_thread2'

    my_thread1.start()
    my_thread2.start()

    my_thread1.join()
    my_thread2.join()
    print(f"{time.strftime('%H:%M:%S')} 主进程结束")


22:21:32 主进程开始
22:21:32 my_thread1 计数3 
22:21:32 my_thread2 计数2 
22:21:34 my_thread2 计数1 22:21:34 my_thread1 计数2 

22:21:36 my_thread1 计数1 
22:21:38 主进程结束

注意：join的用法跟多进程一样，可以参考：Python的多进程_fighter_狂奔的博客-CSDN博客

比如用上面2的实现方法调试：

if __name__=='__main__':
    print(f"{time.strftime('%H:%M:%S')} 主进程开始")
    my_thread1 = threading.Thread(target=threading_task, args=(3,), name='my_thread1')
    my_thread2 = threading.Thread(target=threading_task, args=(2,), name='my_thread2')
    my_thread1.start()
    my_thread2.start()

    my_thread1.join()
    my_thread2.join()

    print(f"{time.strftime('%H:%M:%S')} 主进程结束")

运行结果：

22:18:06 主进程开始
22:18:06 my_thread1 计数3 
22:18:06 my_thread2 计数2 
22:18:08 my_thread2 计数1 22:18:08 my_thread1 计数2 

22:18:10 my_thread1 计数1 
22:18:12 主进程结束

注意：daemon的用法跟多进程一样，可以参考：Python的多进程_fighter_狂奔的博客-CSDN博客

Lock

线程锁（Thread Lock）是一种多线程编程中的同步机制，用于确保多个线程不会同时访问共享资源，从而避免竞争条件和数据损坏。下面是一个使用线程锁的Python多线程示例：

import threading

# 共享资源
counter = 0

# 创建一个线程锁
lock = threading.Lock()

# 线程函数，用于增加共享资源的值
def increment():
    global counter
    # 获取线程锁
    lock.acquire()
    for i in range(100000):
        counter += 1
    # 释放线程锁
    lock.release()

# 创建两个线程
thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
thread3 = threading.Thread(target=increment)

# 启动线程
thread1.start()
thread2.start()
thread3.start()

# 等待线程完成
thread1.join()
thread2.join()
thread3.join()

# 打印最终的共享资源值
print("Final Counter:", counter)


Final Counter: 300000

Semaphore

Semaphore 是 Python 多线程编程中的同步原语之一，它是一个计数信号量，用于控制同时访问共享资源的线程数量。Semaphore 维护一个内部计数器，线程可以尝试获取信号量，如果计数器大于零，线程就能获取信号量，计数器减一；如果计数器为零，线程就需要等待，直到有其他线程释放信号量。

import threading

# 创建一个信号量，最大允许两个线程同时访问共享资源
import time

semaphore = threading.BoundedSemaphore(2)

# 共享资源
shared_resource = []

# 线程函数，用于访问共享资源
def access_shared_resource(thread_id):
    with semaphore:  # 尝试获取信号量
        shared_resource.append(thread_id)
        print(f"{time.strftime('%H:%M:%S')}")
        print(f"Thread {thread_id} accessed the shared resource")
        print(f"Shared Resource: {shared_resource}")
        time.sleep(2)


# 创建多个线程
threads = []
for i in range(5):
    thread = threading.Thread(target=access_shared_resource, args=(i,))
    threads.append(thread)

# 启动线程
for thread in threads:
    thread.start()

# 等待线程完成
for thread in threads:
    thread.join()

print("All threads have finished")

 调试结果：

22:57:50
Thread 0 accessed the shared resource
Shared Resource: [0]
22:57:50
Thread 1 accessed the shared resource
Shared Resource: [0, 1]
22:57:5222:57:52
Thread 3 accessed the shared resource
Thread 2 accessed the shared resource

Shared Resource: [0, 1, 3, 2]
Shared Resource: [0, 1, 3, 2]
22:57:54
Thread 4 accessed the shared resource
Shared Resource: [0, 1, 3, 2, 4]
All threads have finished

Process finished with exit code 0

Condition

Condition 是 Python 用于协调多个线程之间的操作顺序。Condition 允许线程等待某个条件成立，然后通知其他线程，以便它们可以执行相应的操作。

condition = threading.Condition()  两个线程同时使用这个对象用于控制两个线程的消息交互

condition.acquire() 获取锁，准备运行

condition.wait() 释放锁，阻塞中等待唤醒

condition.notify() 唤醒阻塞中的线程去运行

condition.release()  线程执行完成释放资源

import threading

# 共享资源
import time

shared_resource = []
condition = threading.Condition()

# 生产者线程函数，向共享资源中添加数据
def producer():
    for i in range(1, 6):
        with condition:
            shared_resource.append(i)
            print(f"{time.strftime('%H:%M:%S')} 生产: {i}")
            condition.notify()  # 通知消费者线程
            print(f"{time.strftime('%H:%M:%S')} 通知消费者")
            condition.wait()  # 等待消费者线程通知
        time.sleep(1)

# 消费者线程函数，从共享资源中取出数据
def consumer():
    for _ in range(5):
        with condition:
            while not shared_resource:
                print(f"{time.strftime('%H:%M:%S')} 产品不足，通知生产者")
                condition.wait()  # 等待生产者线程通知
            data = shared_resource.pop(0)
            print(f"{time.strftime('%H:%M:%S')} 消费: {data}")
            condition.notify()  # 通知生产者线程
        time.sleep(1)

# 创建生产者和消费者线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

# 启动线程
producer_thread.start()
consumer_thread.start()

# 等待线程完成
producer_thread.join()
consumer_thread.join()

print("All threads have finished")

10:42:43 生产: 1
10:42:43 通知消费者
10:42:43 消费: 1
10:42:45 生产: 2
10:42:45 通知消费者
10:42:45 消费: 2
10:42:46 产品不足，通知生产者
10:42:46 生产: 3
10:42:46 通知消费者
10:42:46 消费: 3
10:42:47 生产: 4
10:42:47 通知消费者
10:42:47 消费: 4
10:42:48 产品不足，通知生产者
10:42:48 生产: 5
10:42:48 通知消费者
10:42:48 消费: 5
All threads have finished

Event（wait、set、clear）

wait方法，线程被阻塞，等待唤醒，wait加参数，表示最多等待多少秒，不加参数表示一直等待

set方法，设置标志位True，wait中的线程被唤醒并执行

clear方法，设置标志位False

import threading

# 共享资源
import time

shared_resource = []
event = threading.Event()

# 生产者线程函数，向共享资源中添加数据
def producer():
    for i in range(1, 6):
        shared_resource.append(i)
        print(f"{time.strftime('%H:%M:%S')} 生产: {i} ")
        event.set()  # 通知消费者线程
        print(f"{time.strftime('%H:%M:%S')} 通知消费者 ")
        event.wait()  # 等待消费者线程通知
        time.sleep(1)

# 消费者线程函数，从共享资源中取出数据
def consumer():
    for _ in range(5):
        while not shared_resource:
            print(f"{time.strftime('%H:%M:%S')} 产品不足，通知生产者 ")
            event.wait()  # 等待生产者线程通知
        data = shared_resource.pop(0)
        print(f"{time.strftime('%H:%M:%S')} 消费: {data} ")
        event.set()  # 通知生产者线程
        time.sleep(1)

# 创建生产者和消费者线程
producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

# 启动线程
producer_thread.start()
consumer_thread.start()

# 等待线程完成
producer_thread.join()
consumer_thread.join()

print("All threads have finished")

运行结果如下：

10:59:35 生产: 1 
10:59:35 通知消费者 
10:59:35 消费: 1 
10:59:36 产品不足，通知生产者 10:59:36 生产: 2 

10:59:36 通知消费者 
10:59:36 消费: 2 
10:59:37 生产: 3 
10:59:37 通知消费者 
10:59:37 消费: 3 
10:59:38 生产: 4 10:59:38 消费: 4 

10:59:38 通知消费者 
10:59:39 生产: 5 10:59:39 消费: 5 

10:59:39 通知消费者 
All threads have finished

Queue

Queue（队列）是 Python 多线程编程中用于线程间通信的重要数据结构。它提供了一种线程安全的方式来在多个线程之间传递数据。Python提供了 queue 模块，其中包含了多种队列类型，包括 Queue（先进先出）、LifoQueue（后进先出） 和 PriorityQueue（优先级队列）。最常见的用法是 Queue。

# 定义一个共享缓存队列，用于两个线程的数据存放和读取
q = queue.Queue(maxsize=5)    当队列存满了后生产者就不在生产数据，需等消费者消费后再生产
import queue
import threading
import time

# 定义一个共享缓存队列，用于两个线程的数据存放和读取
q = queue.Queue(maxsize=5)


def product():
    count = 1
    while True:
        print(f"{time.strftime('%H:%M:%S')} 生产 item{count}")
        q.put(f'item{count}')
        count += 1
        time.sleep(1)
        print(f"当前产品数:{q.qsize()}")


def customer():
    while True:
        print(f"{time.strftime('%H:%M:%S')} 消费 {q.get()}")
        time.sleep(5)


t0 = threading.Thread(target=product)
t1 = threading.Thread(target=customer)

t0.start()
t1.start()

t0.join()
t1.join()

调试结果：

11:23:40 生产 item1
11:23:40 消费 item1
当前产品数:0
11:23:41 生产 item2
当前产品数:1
11:23:42 生产 item3
当前产品数:2
11:23:43 生产 item4
当前产品数:3
11:23:44 生产 item5
11:23:45 消费 item2
当前产品数:3
11:23:45 生产 item6
当前产品数:4
11:23:46 生产 item7
当前产品数:5
11:23:47 生产 item8
11:23:50 消费 item3
当前产品数:5
11:23:51 生产 item9
11:23:55 消费 item4
当前产品数:5
...
...

Pool

面向对象编程中，创建和销毁对象是很浪费时间的，对于频繁的需要创建和销毁的线程的业务中可以使用线程池来处理，线程池中会默认初始化一定数量的线程对象，有任务来时就分配一个空闲线程去处理，如果线程池无空闲就新建一个线程去处理业务。

from multiprocessing.pool import ThreadPool
import threading
import time

# 创建一个线程锁, 使用线程锁来确保输出的有序性，避免输出内容交织在一起
output_lock = threading.Lock()


# 定义一个函数，用于在线程池中并行执行
def square(x):
    with output_lock:
        print(f"{time.strftime('%H:%M:%S')} {x}*{x}={x * x} ")
    time.sleep(2)


if __name__ == '__main__':
    # 创建一个线程池，设置线程数为4（可以根据需要调整）
    pool = ThreadPool(4)

    for i in range(1, 10):
        pool.apply_async(func=square, args=(i,))

    pool.close()
    pool.join()

调试结果展示，每次有4个线程同时运行 

12:00:12 1*1=1 
12:00:12 2*2=4 
12:00:12 3*3=9 
12:00:12 4*4=16 

12:00:14 5*5=25 
12:00:14 6*6=36 
12:00:14 7*7=49 
12:00:14 8*8=64 

12:00:16 9*9=81

fighter_狂奔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 多线程重启方法
09-19
Python的多线程编程在处理并发任务时非常实用，但线程可能会因各种异常而停止运行，这将影响程序的稳定性。本篇文章主要探讨的是如何在Python中实现多线程的自动重启机制，以确保即使有线程崩溃，程序也能继续执行。...
Python 多线程编程-05-threading 模块 - Semaphore 和 BoundedSemaphore
一分耕耘一分收获
02-15 1844
threading.Semaphore 可以理解为一个内置的计数器，当调用 acquire 方法时候内置计数器 -1，对应着申请资源；调用 release 方法时候内置计数器+1，对应着释放可用资源。 BoundedSemaphore 和 Semaphore 的区别的区别在于threading.BoundedSemaphore 会在过多的使用 release() 时候报错 " ValueError: Semaphore released too many times "。
python 信号量 semaphore
LuiChun
04-09 4716
信号量 信号量（英语：semaphore）又称为信号标， 是一个同步对象，用于保持在0至指定最大值之间的一个计数值。 当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一； 当线程完成一次对semaphore对象的释放（release）时，计数值加一。 当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态。 semaphore对象的计数值大于0，为signaled状态；计数值等于0，为nonsignaled状态. 信号量的概念
Python同步编程框架Semaphore的使用，限制线程的并发数量
captain
07-14 714
Python同步编程框架Semaphore是一种同步原语，允许多个线程或进程共享有限数量的资源。
python中信号量（Semaphore）
semicolon_hello的专栏
02-28 779
在Python中，信号量（Semaphore）主要用来控制多个线程或进程对共享资源的访问。信号量本质上是一种计数器，它维护一个许可（permit）数量，每次 acquire() 函数被调用时，如果还有剩余的许可，则减少一个，并允许执行；如果没有剩余许可，则阻塞当前线程直到其他线程释放信号量。在这个例子中，我们创建了一个最多允许3个线程同时执行的信号量。当超过3个线程尝试进入临界区时，其余线程将等待信号量被释放。每个成功获取信号量的线程在完成其工作后会释放信号量，以便其他等待的线程能够继续执行。
python---多进程并发控制 Semaphore 与 互斥锁 LOCK
CN_LiTianpeng的博客
05-18 1396
一、了解锁 应用场景举例描述： Lock 互斥锁:举例说明–有三个同事同时需要上厕所，但是只有一间厕所，将同事比作进程，多个进程并打抢占一个厕所，我们要保证顺序优先， 一个个来，那么就必须串行，先到先得，有人使用了，就锁住，结束后剩余的人继续争抢 1、利用Lock来处理 模拟三个同事抢占厕所 from multiprocessing import Process from multiprocessing import Lock import time import random def task1(p,
详解Python多线程下的list
09-16
本篇文章主要探讨了Python多线程下对列表(list)进行操作时的安全性问题。 首先，我们要明确一个概念：线程安全。线程安全指的是在多线程环境中，一个数据结构或函数在任何时候都能正确地处理多个线程的并发访问，...
python多线程接口案例
12-21
在这个特定的“python多线程接口案例”中，我们看到一个脚本被设计用来模拟50个或更多的用户并发访问某个内控公司的业务接口，并生成Excel报告记录结果。以下是对整个脚本的详细解析： 1. **获取Cookie**： 通过...
Python多线程详解
01-27
线程有5种状态，状态转换的过程如下图所示：多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。考虑这样一种情况：一个列表里所有元素都是0，线程...
python多线程定时器
03-11
总结起来，`python多线程定时器`的实现涉及到Python的`threading`和`time`模块，通过`Thread`和`Timer`类来创建和管理线程，使用定时器控制线程的启动时间。主程序`main.py`使用这些工具来安排多个任务按设定的间隔...
python高并发-semaphore
qq_41969287的博客
06-17 542
semaphore信号量可以通过内置计数器来控制同时运行线程的数量 每当调用acquire()时，内置计数器-1,直到为0的时候阻塞 每当调用release()时，内置计数器+1，并让某个线程的acquire()从阻塞变为不阻塞 Semaphore: 在调用release()函数时，不会检查，增加的计数是否超过上限（没有上限，会一直上升） BoundedSemaphore: 在调用release()函数时，会检查，增加的计数是否超过上限，这样就保证了使用的计数 Thread ：线程类，这是用的最多的一个
python的多线程
热门推荐
weixin_61805348的博客
05-28 7万+
python多线程 一、线程的概念 线程是CPU分配资源的基本单位。当一程序开始运行，这个程序就变成了一个进程，而一个进程相当于一个或者多个线程。当没有多线程编程时，一个进程相当于一个主线程；当有多线程编程时，一个进程包含多个线程（含主线程）。使用线程可以实现程序大的开发。 多个线程可以在同一个程序中运行，并且每一个线程完成不同的任务。 多线程实现后台服务程序可以同时处理多个任务，并不发生阻塞现象。 多线程的程序设计的特点就是能够提高程序执行效率和处理速度。python程序可以同时并行运行多个相对独立的线
Python——信号量、条件变量、事件
W_000的博客
01-21 1629
1.信号量（Semaphore） 信号量通常用于保护数量有限的资源，例如数据库服务器。在资源数量固定的任何情况下，都应该使用有界信号量。在生成任何工作线程前，应该在主线程中初始化信号量。 信号量提供acquire方法和release方法，每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用release方法将内部计数器更新到大于1位置。 信号量也是一把锁，用来控制线程并发数。信号量通过一...
Python 语法特性｜Semaphore 和 BoundedSemaphore 信号量详解
长行
10-11 868
信号量（Semaphore）是一种计数器，用于控制能同时访问某个资源的线程数量。它主要有两个操作：P（等待）和　V（释放）。当一个线程要访问共享资源时，它会调用 P 操作，如果计数器大于 0，则将计数器的值减 1，并允许访问资源；如果计数器等于 0，则线程被阻塞，直到计数器大于 0。当一个线程访问完共享资源后，会调用 V 操作，将计数器的值加 1，以允许其他线程访问资源。在 Python 的类和类中，acquire()方法对应 P 操作，release()方法对应 V 操作。Python 的。
线程
weixin_30379973的博客
08-02 210
threading模块 线程的创建Threading.Thread类 线程的创建 from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=...
一文吃透python多线程（全面总结）
qq_43745578的博客
01-23 1万+
python多线程，包含创建、线程锁、线程通信、线程池等讲解
使用Python的Turtle库绘制动态风车
最新发布
爱写代码的小朋友
07-20 377
python绘制风车
Python 多线程
09-19
Python多线程的优点是能够提高程序的执行效率，特别是在IO操作较多的情况下，多线程可以充分利用CPU的空闲时间。另外，多线程还可以实现一些并发的功能，例如同时下载多个文件、同时处理多个网络请求等。 然而，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值