第40章 Python3 多线程教程

最新推荐文章于 2024-06-14 11:20:52 发布

你得不到的念想

最新推荐文章于 2024-06-14 11:20:52 发布

阅读量375

点赞数 2

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/phlcsdn2023/article/details/128356042

版权

Python 专栏收录该内容

52 篇文章 3 订阅

订阅专栏

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
程序的运行速度可能加快。
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下咱们可以释放一些珍贵的资源如内存占用等等。

每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。

指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。

线程可以被抢占（中断）。
在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） – 这就是线程的退让。

线程可以分为:

**内核线程：**由操作系统内核创建和撤销。
**用户线程：**不需要内核支持而在用户程序中实现的线程。

Python3 线程中常用的两个模块为：

_thread
threading(推荐使用)

thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 “_thread”。

开始学习Python线程

Python中使用线程有两种方式：函数或者用类来包装线程对象。

函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:


    _thread.start_new_thread ( function, args[, kwargs] )

参数说明:

function - 线程函数。
args - 传递给线程函数的参数,他必须是个tuple类型。
kwargs - 非必输参数。


    实例 
    #!/usr/bin/python3
    
    import _thread
    import time
    
    # 为线程定义一个函数
    def print_time( threadName, delay):
       count = 0
       while count < 5:
          time.sleep(delay)
          count += 1
          print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
    
    # 创建两个线程
    try:
       _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
       _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
    except:
    
       print ("Error: 无法启动线程")
    while 1:
       pass

执行以上程序输出结果请在输出结果查看


    Thread-1: Wed Jan  5 17:38:08 2022
    Thread-2: Wed Jan  5 17:38:10 2022
    Thread-1: Wed Jan  5 17:38:10 2022
    Thread-1: Wed Jan  5 17:38:12 2022
    Thread-2: Wed Jan  5 17:38:14 2022
    Thread-1: Wed Jan  5 17:38:14 2022
    Thread-1: Wed Jan  5 17:38:16 2022
    Thread-2: Wed Jan  5 17:38:18 2022
    Thread-2: Wed Jan  5 17:38:22 2022
    Thread-2: Wed Jan  5 17:38:26 2022

执行以上程后可以按下 ctrl-c 退出。

线程模块

Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

threading.currentThread(): return 当前的线程变量。
threading.enumerate(): return 一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): return 正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

run(): 用以表示线程活动的方法。
**start()😗*启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是非必输的超时发生。
isAlive(): return 线程是否活动的。
getName(): return 线程名。
setName(): 设置线程名。

使用 threading 模块创建线程

咱们可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：


    实例 
    #!/usr/bin/python3
    
    import threading
    import time
    exitFlag = 0
    class myThread (threading.Thread):
    
        def __init__(self, threadID, name, delay):
    
            threading.Thread.__init__(self)
    
            self.threadID = threadID
    
            self.name = name
    
            self.delay = delay
    
        def run(self):
    
            print ("开始线程：" + self.name)
    
            print_time(self.name, self.delay, 5)
    
            print ("退出线程：" + self.name)
    
    def print_time(threadName, delay, counter):
    
        while counter:
    
            if exitFlag:
    
                threadName.exit()
    
            time.sleep(delay)
    
            print ("%s: %s" % (threadName, time.ctime(time.time())))
    
            counter -= 1
    
    # 创建新线程
    
    thread1 = myThread(1, "Thread-1", 1)
    
    thread2 = myThread(2, "Thread-2", 2)
    # 开启新线程
    
    thread1.start()
    
    thread2.start()
    
    thread1.join()
    
    thread2.join()
    
    print ("退出主线程")

以上程序执行结果如下；


    开始线程：Thread-1
    开始线程：Thread-2
    Thread-1: Wed Jan  5 17:34:54 2022
    Thread-2: Wed Jan  5 17:34:55 2022
    Thread-1: Wed Jan  5 17:34:55 2022
    Thread-1: Wed Jan  5 17:34:56 2022
    Thread-2: Wed Jan  5 17:34:57 2022
    Thread-1: Wed Jan  5 17:34:57 2022
    Thread-1: Wed Jan  5 17:34:58 2022
    退出线程：Thread-1
    Thread-2: Wed Jan  5 17:34:59 2022
    Thread-2: Wed Jan  5 17:35:01 2022
    Thread-2: Wed Jan  5 17:35:03 2022
    退出线程：Thread-2
    退出主线程

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：

多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。

考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。

那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。

经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。


    实例 
    #!/usr/bin/python3
    import threading
    
    import time
    
    class myThread (threading.Thread):
    
        def __init__(self, threadID, name, delay):
    
            threading.Thread.__init__(self)
    
            self.threadID = threadID
    
            self.name = name
    
            self.delay = delay
    
        def run(self):
    
            print ("开启线程： " + self.name)
    
            # 获取锁，用于线程同步
    
            threadLock.acquire()
    
            print_time(self.name, self.delay, 3)
    
            # 释放锁，开启下一个线程
    
            threadLock.release()
    
    def print_time(threadName, delay, counter):
    
        while counter:
    
            time.sleep(delay)
    
            print ("%s: %s" % (threadName, time.ctime(time.time())))
    
            counter -= 1
    threadLock = threading.Lock()
    
    threads = []
    # 创建新线程
    thread1 = myThread(1, "Thread-1", 1)
    thread2 = myThread(2, "Thread-2", 2)
    
    # 开启新线程
    thread1.start()
    thread2.start()
    # 添加线程到线程列表
    threads.append(thread1)
    threads.append(thread2)
    
    # 等待所有线程完成
    for t in threads:
        t.join()
    print ("退出主线程")

执行以上程序，输出结果请在输出结果查看


    开启线程： Thread-1
    开启线程： Thread-2
    Thread-1: Wed Jan  5 17:36:50 2022
    Thread-1: Wed Jan  5 17:36:51 2022
    Thread-1: Wed Jan  5 17:36:52 2022
    Thread-2: Wed Jan  5 17:36:54 2022
    Thread-2: Wed Jan  5 17:36:56 2022
    Thread-2: Wed Jan  5 17:36:58 2022
    退出主线程

线程优先级队列（ Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

Queue 模块中的常用方法:

Queue.qsize() return 队列的大小
Queue.empty() 如果队列为空，return True,反之False
Queue.full() 如果队列满了，return True,反之False
Queue.full 与 maxsize 大小对应
Queue.get([block[, timeout]])获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)
Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() 实际上意味着等到队列为空，再执行别的操作


    实例 
    #!/usr/bin/python3
    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 processing %s" % (threadName, data))
    
            else:
    
                queueLock.release()
    
            time.sleep(1)
    
    
    
    threadList = ["Thread-1", "Thread-2", "Thread-3"]
    
    nameList = ["One", "Two", "Three", "Four", "Five"]
    
    queueLock = threading.Lock()
    
    workQueue = queue.Queue(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 ("退出主线程")

以上程序执行结果请在输出结果查看


    开启线程：Thread-1
    开启线程：Thread-2
    开启线程：Thread-3
    Thread-3 processing One
    Thread-1 processing Two
    Thread-2 processing Three
    Thread-3 processing Four
    Thread-1 processing Five
    退出线程：Thread-3
    退出线程：Thread-2
    退出线程：Thread-1
    退出主线程

本专栏所有文章

第1章 Python3 教程	第2章 Python3 简介教程
第3章 Python3 环境搭建教程	第4章 Python3 VScode教程
第5章 Python3 基础语法教程	第6章 Python3 基本数据类型教程
第7章 Python3 数据类型转换教程	第8章 Python3 推导式教程
第9章 Python3 解释器教程	第10章 Python3 注释教程
第11章 Python3 运算符教程	第12章 Python3 数字(Number)教程
第13章 Python3 字符串教程	第14章 Python3 列表教程
第15章 Python3 元组教程	第16章 Python3 字典教程
第17章 Python3 集合教程	第18章 Python3 编程第一步教程
第19章 Python3 条件控制教程	第20章 Python3 循环语句教程
第21章 Python3 迭代器与生成器教程	第22章 Python3 函数教程
第23章 Python3 数据结构教程	第24章 Python3 模块教程
第25章 Python3 输入和输出教程	第26章 Python3 File教程
第27章 Python3 OS教程	第28章 Python3 错误和异常教程
第29章 Python3 面向对象教程	第30章 Python3 命名空间/作用域教程
第31章 Python3 标准库概览教程	第32章 Python3 实例教程
第33章 Python 测验教程	第34章 Python3 正则表达式教程
第35章 Python3 CGI编程教程	第36章 Python3 MySQL(mysql-connector)教程
第37章 Python3 MySQL(PyMySQL)教程	第38章 Python3 网络编程教程
第39章 Python3 SMTP发送邮件教程	第40章 Python3 多线程教程
第41章 Python3 XML 解析教程	第42章 Python3 JSON教程
第43章 Python3 日期和时间教程	第44章 Python3 内置函数教程
第45章 Python3 MongoDB教程	第46章 Python3 urllib教程
第47章 Python uWSGI 安装配置教程	第48章 Python3 pip教程
第49章 Python3 operator教程	第50章 Python math教程
第51章 Python requests教程	第52章 Python random教程
第53章 Python3 os.replace() 方法教程

寄语

本文有 phlcsdn2023 原创，欢迎点赞、转载，博客地址：https://blog.csdn.net/phlcsdn2023

青年充满阳光和爱。青年是幸福的，因为他们能看到美。这种能力一旦失去，毫无慰籍的老年就开始了，衰落和不幸就开始了。谁能保持发现美的能力，谁就不会变老。
一个好的东西往往是说不清楚的，说得清楚的往往不是好东西。
我们有自己的小默契，我喜欢的她绝不讨厌，而我讨厌的她绝不喜欢。
我现在这么努力奋斗，就是为了以后我爱的能够幸福。
如果你想成功，那么你要记住：遗产为零，诚实第一，学习第二，礼貌第三，刻苦第四，精明第五。

你得不到的念想

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
第40章 Python3 多线程教程

每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。thread 模块已被废弃。用户可以使用 threading 模块代替。
复制链接

扫一扫