Python攻城师的成长————线程理论（消息队列、IPC机制、生产者消费者模型、GIL全局解释器锁）

于 2022-04-20 16:35:13 发布
阅读量597 收藏
点赞数
分类专栏： Python高级编程 文章标签： python 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fonnt/article/details/124298141
版权

今日学习目标

  • 学习有关线程的知识点以及代码实现，知道什么是消息队列与生产者消费者模型

文章目录

学习内容

  • 消息队列（简易本地版）
  • IPC机制(进程间通信)
  • 生产者消费者模型
  • 线程理论(重要)
  • 开设线程的两种方式
  • 线程实现TCP服务端并发
  • 线程join方法
  • 线程间数据共享
  • 守护线程
  • GIL全局解释器锁

一、消息队列（简易本地版）

什么是消息队列

我们可以把消息队列比作是一个存放消息的容器，当我们需要使用消息的时候可以取出消息供自己使用。

使用方式

from multiprocessing import Queue
q = Queue(5)  # 自定义队列的长度

常用方法

1. q.put()  # 朝队列中存放数据
超出最大长度 原地阻塞等待队列中出现空位

2. q.full()  # 判断队列是否满了

3. q.get() # 取出队列中数据

4. q.empty()  # 判断队列是否空了

5. q.get_nowait()  # 队列中如果没有值 直接报错

from multiprocessing import Queue


q = Queue(5)  # 自定义队列的长度
# 朝队列中存放数据
q.put(111)
q.put(222)
q.put(333)
print(q.full())  # False  判断队列是否满了
q.put(444)
q.put(555)
print(q.full())  # True
# q.put(666)  # 超出最大长度 原地阻塞等待队列中出现空位
print(q.get())
print(q.get())
print(q.empty())  # False  判断队列是否空了
print(q.get())
print(q.get())
print(q.get())
print(q.empty())  # True
# print(q.get())  # 队列中没有值 继续获取则阻塞等待队列中给值
print(q.get_nowait())  # 队列中如果没有值 直接报错

特别提醒
full()、empty()、get_nowait()
上述方法能否在并发的场景下精准使用?
不能用，因为会出现极限情况。eg：使用full()方法判断完队列后，可能出现继续存取的情况

队列是因为它可以支持进程间数据通信

二、IPC机制(进程间通信)

简介

进程间通信或跨进程通信，指两个进程之间进行数据交换。进程间通信或跨进程通信，指两个进程之间进行数据交换。

用法举例

from multiprocessing import Process, Queue


def producer(q):
    q.put('子进程producer往队列中添加值')

def consumer(q):
    print('子进程consumer从队列中取值>>>:', q.get())


if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q, ))
    p1 = Process(target=consumer, args=(q,))
    p.start()
    p1.start()
    print('主进程')

三、生产者消费者模型

简介

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

代码实现

  • 实例1：基于队列实现生产者消费者模型

from multiprocessing import Process, Queue
import time
import random
import os
 
 
def consumer(q):
    while 1:
        res = q.get()
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))
 
 
def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "食物%s" % i
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))
 
 
if __name__ == '__main__':
    q = Queue()
    p = Process(target=producer, args=(q,))
    c = Process(target=consumer, args=(q,))
    p.start()
    c.start()
    print("主进程结束")

分析：此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，则一直处于死循环中且卡在q.get()这一步。

解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环

  • 最终版：JoinableQueue() 实现生产者消费者模型
    JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：
  1. q.task_done()：使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。
  2. q.join()：生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。
from multiprocessing import Process, JoinableQueue
import time
import random
import os
 
 
def consumer(q):
    while 1:
        res = q.get()
        if res is None:  # 收到信号就结束
            break
        time.sleep(random.randint(2, 5))
        print('\033[31m%s消耗了%s\033[0m' % (os.getpid(), res))
 
 
def producer(name, q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = "%s %s" % (name, i)
        q.put(res)
        print('\033[32m%s生产了%s\033[0m' % (os.getpid(), res))
    q.join()
 
 
if __name__ == '__main__':
    q = JoinableQueue()
    p_one = Process(target=producer, args=("包子", q))
    p_two = Process(target=producer, args=("馒头", q))
    p_thr = Process(target=producer, args=("面条", q))
 
    c_one = Process(target=consumer, args=(q,))
    c_two = Process(target=consumer, args=(q,))
 
    c_one.daemon = True
    c_two.daemon = True
 
    p_lst = [p_one, p_two, p_thr, c_one, c_two]
 
    for p in p_lst:
        p.start()
 
    p_one.join()
    p_two.join()
    p_thr.join()
 
    print("主进程结束")

分析：

  • 主进程等—>p1,p2,p3等---->c1,c2。
  • p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据。
  • 因而c1,c2也没有存在的价值了,不需要继续阻塞在进程中影响主进程了。应该随着主进程的结束而结束,所以设置成守护进程就可以了。

四、线程理论(重要)

简介

线程是程序中一个单一的顺序控制流程。进程内有一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指令运行时的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。Python多线程用于I/O操作密集型的任务，如SocketServer网络并发，网络爬虫。

Python创建Thread对象语法如下：

import threading
threading.Thread(target=None, name=None,  args=())

主要参数说明：

  1. target 是函数名字，需要调用的函数。

  2. name 设置线程名字。

  3. args 函数需要的参数，以元祖( tuple)的形式传入

Thread 对象主要方法说明:

  1. run(): 用以表示线程活动的方法。

  2. start():启动线程活动。

  3. join(): 等待至线程中止。

  4. isAlive(): 返回线程是否活动的。

  5. getName(): 返回线程名。

  6. setName(): 设置线程名。

进程与线程

  • 进程:资源单位
  • 线程:执行单位

进程相当于车间(一个个空间)，线程相当于车间里面的流水线(真正干活的)
一个进程中至少有一个线程

进程仅仅是在内存中开辟一块空间(提供线程工作所需的资源)
线程真正被CPU执行，线程需要的资源跟所在进程的要

开设线程的两种方式

函数式创建线程和创建线程类

补充
Python的threading模块有个current_thread()函数，它将返回当前线程的示例。从当前线程的示例可以获得前运行线程名字。

threading.current_thread().getName()
  • 第一种创建线程方式：函数式创建线程
    创建线程的时候，只需要传入一个执行函数和函数的参数即可完成threading.Thread实例的创建。下面的例子使用Thread类来产生2个子线程，然后启动2个子线程并等待其结束。
import threading
import time,random,math
 
# idx 循环次数
def printNum(idx):
    for num in range(idx ):
        #打印当前运行的线程名字
        print("{0}\tnum={1}".format(threading.current_thread().getName(), num) )
        delay = math.ceil(random.random() * 2)
        time.sleep(delay)
 
 
if __name__ == '__main__':
    th1 = threading.Thread(target=printNum, args=(2,),name="thread1"  )
    th2 = threading.Thread(target=printNum, args=(3,),name="thread2" )
 
    #启动2个线程
    th1.start()
    th2.start()
 
    #等待至线程中止
    th1.join()
    th2.join()
    print("{0} 线程结束".format(threading.current_thread().getName()))
  • 第二种创建线程方式：创建线程类
    直接创建threading.Thread的子类来创建一个线程对象,实现多线程。通过继承Thread类，并重写Thread类的run()方法，在run()方法中定义具体要执行的任务。在Thread类中，提供了一个start()方法用于启动新进程，线程启动后会自动调用run()方法。
import threading
import time,random,math
 
class MutliThread(threading.Thread):
    def __init__(self, threadName,num):
        threading.Thread.__init__(self)
        self.name = threadName
        self.num = num
 
    def run(self):
        for i in range(self.num):
            print("{0} i={1}".format(threading.current_thread().getName(), i))
            delay = math.ceil(random.random() * 2)
            time.sleep(delay)
 
 
if __name__ == '__main__':
    thr1 = MutliThread("thread1",3)
    thr2 = MutliThread("thread2",2)
    
    # 启动线程
    thr1.start()
    thr2.start()
 
    # 等待至线程中止
    thr1.join()
    thr2.join()
    print("{0} 线程结束".format(threading.current_thread().getName()))

线程join方法

from threading import Thread
import time


def task(name):
    print(f'{name} is running')
    time.sleep(3)
    print(f'{name} is over')


t = Thread(target=task, args=('jason', ))
t.start()
t.join()  # 主线程代码等待子线程代码运行完毕之后再往下执行
print('主线程')
"""
主线程为什么要等着子线程结束才会结束整个进程  
    因为主线程结束也就标志着整个进程的结束 要确保子线程运行过程中所需的各项资源
"""

线程间数据共享

from threading import Thread

money = 10000000000
def task():
    global money
    money = 1

t = Thread(target=task)
t.start()
t.join()
print(money)

守护线程

  • 简介
    在多线程开发中，如果子线程设定为了守护线程，守护线程会等待主线程运行完毕后被销毁。一个主线程可以设置多个守护线程，守护线程运行的前提是，主线程必须存在，如果主线程不存在了，守护线程会被销毁。
from threading import Thread
import time


def task(name):
    print(f'{name} is running')
    time.sleep(3)
    print(f'{name} is over')

t1 = Thread(target=task, args=('jason',))
t2 = Thread(target=task, args=('kevin',))
t1.daemon = True
t1.start()
t2.start()
print('主线程')

注意：
主线程执行完毕后，程序不会等待守护线程执行完毕后就退出了。设置线程对象为守护线程，一定要在线程对象调用start()函数前设置。

线程实现TCP服务端并发

import socket
from threading import Thread

server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen()


def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())


while True:
    sock, addr = server.accept()
    # 每类一个客户端就创建一个线程做数据交互
    t = Thread(target=talk, args=(sock,))
    t.start()

五、GIL全局解释器锁

  • 官方文档

In CPython, the global interpreter lock, or GIL, is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

翻译：
在 CPython 解释器中，全局解释锁 GIL 是在于执行 Python 字节码时，为了保护访问 Python 对象而阻止多个线程执行的一把互斥锁。这把锁的存在主要是因为 CPython 解释器的内存管理不是线程安全的。然而直到今天 GIL 依旧存在，现在的很多功能已经习惯于依赖它作为执行的保证。

定义总结与回顾

  • 回顾
    python解释器的类别有很多
    Cpython Jpython Ppython
    垃圾回收机制
    应用计数、标记清除、分代回收
  • 定义总结

  1. GIL只存在于CPython解释器中，不是python的特征

  2. GIL是一把互斥锁用于阻止同一个进程下的多个线程同时执行
    原因是因为CPython解释器中的垃圾回收机制不是线程安全的

  3. 反向验证GIL的存在 如果不存在会产生垃圾回收机制与正常线程之间数据错乱
    GIL是加在CPython解释器上面的互斥锁
    同一个进程下的多个线程要想执行必须先抢GIL锁 所以同一个进程下多个线程肯定不能同时运行 即无法利用多核优势

问题引出

  • 问题1:同一个进程下的多个线程不能同时执行即不能利用多核优势
    回答:虽然用一个进程下的多个线程不能利用多核优势 但是还可以开设多进程

  • 问题2:python的多线程速度太慢 有多核都不能用
    回答:要结合实际情况

    1. 如果多个任务都是IO密集型的 那么多线程更有优势(消耗的资源更少)
      多道技术:切换+保存状态
    2. 如果多个任务都是计算密集型 那么多线程确实没有优势 但是可以用多进程
      CPU越多越好

总结 ：
以后用python就可以多进程下面开设多线程从而达到效率最大化
1.所有的解释型语言都无法做到同一个进程下多个线程利用多核优势
2.GIL在实际编程中其实不用考虑

絵飛的
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值