python_threading多线程、queue安全队列

简介: python_threading多线程、queue安全队列

多线程


image.png

image.png

threading库

常用方法

  • currentThread() 返回当前的线程变量
  • enumerate() 返回一个正在运行的线程list
  • activeCount() 返回正在运行的吸纳从数量(类似len(enumerate))

thread类

查询定义的thread类中start、run等方法

thread类

  • run() 线程活动的方法
  • start() 启动线程
  • join([time]) 阻塞调用线程直至线程的joiin()方法被调用终止
  • isActive 是否执行
  • getName() 但返回线程的名字
  • setName() 设置线程的名字

例:单线程、多线程分别执行两个函数的过程

import threading,time
def coding():
    for t in range(0,2):
        print('正在写python!')
        run_count()
        time.sleep(1)#延迟1s
def game():
    for t in range(0,2):
        print('游戏中!')
        run_count()
        time.sleep(1)#延迟1秒
def run_count():
    print('当前线程数量:',threading.active_count())
def single_thread():#单线程
    coding()
    game()
def muti_thread():#多线程
    fun1=threading.Thread(target=coding)
    fun2=threading.Thread(target=game)
    fun1.start()
    fun2.start()
if __name__=='__main__':
    print('单线程')
    single_thread()#
    print('多线程')
    muti_thread()

继承thread类

重构上面的代码

import threading,time
class codeWork(threading.Thread):#继承thread.Thread类
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name#名字自定义
    def run(self):
        the_thread=threading.current_thread()
        for i in range(2):
            print('正在写python!',the_thread.name)
            time.sleep(1)
class gameWork(threading.Thread):
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name#名字自定义
    def run(self):
        the_thread=threading.current_thread()
        for i in range(2):
            print('游戏中',the_thread.name)
            time.sleep(1)
def muti_thread():
    th1=codeWork('写代码的进程')
    th2=gameWork('游戏的进程')
    th1.start()
    th2.start()
if __name__=='__main__':
    muti_thread()

全局变量的问题

不加线程锁

因为多线程执行的不确定性,粗暴的更改全局变量可能会造成bug

例:多线程执行value++,查看全局变量value的值

import threading
value=0
class global_Work1(threading.Thread):#继承thread.Thread类
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name#名字自定义
    def run(self):
        the_thread=threading.current_thread()
        global value  # 定义全局变量
        for i in range(1,20):
            value+=1
            print('全局变量c:',value,'\t运行的进程:',threading.active_count(),the_thread.name)
class global_Work2(threading.Thread):#继承thread.Thread类
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name#名字自定义
    def run(self):
        the_thread=threading.current_thread()
        global value  # 定义全局变量
        for i in range(1,20):
            value+=1
            print('全局变量c:',value,'\t运行的进程:',threading.active_count(),the_thread.name)
def muti_thread():
    th1=global_Work1('全局变量测试1')
    th2 = global_Work1('全局变量测试2')
    th1.start()
    th2.start()
if __name__=='__main__':
    # global c  # 定义全局变量
    muti_thread()

添加线程锁Lock(线程同步)

threading.Lock()

  • acquire()
  • release()

queue线程安全队列

内置的线程安全模块queue(同步、安全,fifo)

  • qsize() 队列大小
  • empty() 队列是否为空
  • full() 队列是否满了
  • get()队列的最后一个数据
  • put() 数据加入队列

例:queue同步执行

import queue
import threading
import time
exitFlag = 0
class myThread(threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print("开始 " + self.name)
        process_data(self.name, self.q)
        print("退出 " + self.name)
def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()#获取线程之后释放锁
            print("%s 运行 %s" % (threadName, data))
        else:
            queueLock.release()
        time.sleep(1)
if __name__=='__main__':
    threadList = ["Thread-1", "Thread-2", "Thread-3"]
    nameList = ["线程1", "线程2", "线程3", "线程4", "线程5"]  #
    queueLock = threading.Lock()  # 线程锁
    workQueue = queue.Queue(10)  # 大小为10的队列
    threads = []
    threadID = 1
    # 创建新线程
    for tName in threadList:  # 分配线程名字
        thread = myThread(threadID, tName, workQueue)
        thread.start()
        threads.append(thread)
        threadID += 1
    # 填充队列
    queueLock.acquire()  # 加锁
    for word in nameList:
        workQueue.put(word)
    queueLock.release()  # 解锁
    # 等待队列清空
    while not workQueue.empty():
        pass#占位
    # 通知线程是时候退出
    exitFlag = 1
    # 等待所有线程完成
    for t in threads:
        t.join()
    print("Exiting Main Thread")


目录
相关文章
|
23天前
|
安全 数据处理 开发者
Python中的多线程编程:从入门到精通
本文将深入探讨Python中的多线程编程,包括其基本原理、应用场景、实现方法以及常见问题和解决方案。通过本文的学习,读者将对Python多线程编程有一个全面的认识,能够在实际项目中灵活运用。
|
5天前
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
|
17天前
|
Java Unix 调度
python多线程!
本文介绍了线程的基本概念、多线程技术、线程的创建与管理、线程间的通信与同步机制,以及线程池和队列模块的使用。文章详细讲解了如何使用 `_thread` 和 `threading` 模块创建和管理线程,介绍了线程锁 `Lock` 的作用和使用方法,解决了多线程环境下的数据共享问题。此外,还介绍了 `Timer` 定时器和 `ThreadPoolExecutor` 线程池的使用,最后通过一个具体的案例展示了如何使用多线程爬取电影票房数据。文章还对比了进程和线程的优缺点,并讨论了计算密集型和IO密集型任务的适用场景。
37 4
|
24天前
|
Python
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析,我们将了解何时使用多线程或多进程更为合适,并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。
|
1月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
41 1
C++ 多线程之初识多线程
|
22天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
16 3
|
22天前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
15 2
|
22天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
28 2
|
22天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
28 1
|
22天前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
33 1