并发编程 - 拾贝312

并发和并行

并发：指的是任务数多于CPU核数，通过操作系统的各种任务调度算法，实现多个任务“一起”执行
并行：指的是任务数小于CPU核数，即任务真的是一起执行

队列

python的Queue模块中提供了同步的、线程安全的队列类，包含：FIFO（先入先出）队列queue、LIFO（后入先出）队列LifoQueue,优先级别队列PriorityQueue,这些队列都实现了锁，能够在多线程中直接使用。可以使用队列来实现线程间的同步
初始化Queue（）对象，如果括号中没有指定最大可接收的消息数量，或者数量为负值，那么久代表可接受对的消息没有上限

队列的方法：

def task_done(self) ：在完成一项工作后，使用task_done（）方法可以向队列发送一个消息表示该任务执行完毕
def join(self) ：等待队列中所有的任务执行完毕之后，再往下，否则一直等待
join()是判断的依据，不单单是列队中没有数据，数据get出去之后，要使用task_done()向队列发送一个信号，表示该任务执行完毕
def qsize(self) :返回当前队列包含的消息数量
def empty(self) ：如果队列为空，返回True，反之False
def full(self)　　：如果队列满了，返回True，反之False
def put(self,item,block=True,timeout=None) ：添加数据
def get(self,block=True,timeout=None) ：获取队列，timeout设置等待时间
def put_nowait(self,item)
def get_nowait(self,item)

from queue import Queue, LifoQueue, PriorityQueue

# 实例化一个队列对象
q = Queue()

# 队列添加数据:put,put_nowait
q.put('python001')
q.put('python006', timeout=3)  # 参数timeout 设置等待时间
q.put_nowait('pythhn00000')   # 添加数据不等待

# get: 获取数据
print(q.get())
print(q.get())

# qsize:获取队列中数据的长度
print(q.qsize())

# 判断队列是否为空
print(q.empty())

# 判断队列是否已满
print(q.full())

from queue import Queue

q=Queue(2)
q.put(1)
q.put(2)
q.task_done()
#q.task_done()
print("join1") 
q.join()
print("join2")

"""

只会输出 join1

"""

进程

进程：一个程序运行起来后，代码+用到的资源称为进程，它是操作系统分配资源的基本单位

不仅可以通过现场完成多任务，进程也是可以的

进程的状态

工作中，任务数往往大于CPU的核数，即一定有一些任务正在执行，而另一些任务在等待执行
就绪状态：运行条件都已经满足，正等在CPU执行
执行状态： CPU正在执行其功能
等待状态：等待某些条件满足，例如一个程序sleep了，就处于等待状态

window下，执行多进程，程序执行入口需要写在 if __name__=="__main__"函数里

进程、线程对比

功能

进程，能够完成多任务，比如在一台电脑上能够同时运行多个软件
线程，能够完成多任务，比如一个QQ中的多个聊天窗口

定义的不同

进程是系统进行资源分配的单位
线程是进程的一个实体，是CPU调度和任务分派的基本单位，它是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源，但是她可与同属一个进程的其他线程共享进程所拥有的全部资源

queue.Queue:只能在同一个进程中的多个线程之间使用

multiprocessing.Queue: 可以在多个进程之间跨进程输出数据

进程池

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态生成多个进程，但如果是上百甚至上千个目标，手动去创建进程的工作量巨大，这个时候就可以用到该模块提供的Pool方法
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中，如果池还没有满，那么就有创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么请求就会等待，直到池中有进程结束，才会有之前的进程来执行新的任务

Pool常用方法：

apply_async(func[,args[,kwds]]) :使用非阻塞方式调用func(并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程)，args为传递给func的参数列表，kwds为传递给func的关键字参数列表
close() :关闭Pool，使其不再接受新的任务
join() : 主进程堵塞，等待子进程的退出，必须在close之后使用

进程池的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue(),而不是multiprocessing。Queue(),否则就会报错

from multiprocessing import Pool
import os
import time
import random


def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg, os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random() * 2)
    t_stop = time.time()
    print(msg, "执行完毕，耗时%0.2f" % (t_stop - t_start))


if __name__ == '__main__':
    po = Pool(3)  # 定义一个进程池，最大进程数3
    for i in range(0, 10):
        # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
        # 每次循环将会用空闲出来的子进程去调用目标
        po.apply_async(worker, (i,))
    #
    print("----start----")
    po.close()  # 关闭进程池，关闭后po不再接收新的请求
    po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
    print("-----end-----")

协程

协程：又称微线程，是python中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元。因为它自带CPU上下文，这样只要在合适gr的时机，可以把一个协程切换到另一个协程。只要这个过程中保存或者恢复CPU上下文那么程序还是可以运行的。

通俗的描述：

协程是线程中的一个特殊的函数,这个函数执行的时候，可以在某个地方暂停，并且可以重新在暂停处，继续运行，协程在进行切换的时候，只需要保存当前协程函数中的一些临时变量等信息，然后切换到另外一个函数中运行，并且切换的次数以及什么时候再切换到原来的函数，都可以由开发者自己决定。
协程切换的时候，既不涉及资源切换，也不涉及操作系统的调度，而是在同一个程序中切换不同的函数执行，所以协程占用的资源非常少，一秒钟可以切换上百万次系统
协程与进程、线程相比并不是一个维度的概念

gevent模块

　　原理：当一个协程遇到IO操作时，比如访问网络，就会自动切换到其他greenlet，等到IO操作完成，再在合适的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent就会自动切换协程，就能保证总有greenlei在运行，而不是等待IO

程序补丁：monkey.patch_all()

打补丁作用，只要有耗时的地方，自动切换任务，不局限于gevent.sleep()

注意点：只能在单线程中使用，不能在多线程中使用

import gevent

from gevent import monkey

monkey.patch_all()

import time
from gevent.monkey import patch_all

patch_all()

import gevent
import requests

def work1(name):
    for i in range(10):
        print('这个是work1', name)
        time.sleep(0.1)


def work2():
    for i in range(10):
        print('这个是work2')
        time.sleep(0.1)


g1 = gevent.spawn(work1, 'aa')
g2 = gevent.spawn(work2)

g1.join()
g2.join()

发表于 2022-02-20 23:00 拾贝312 阅读(44) 评论(0) 收藏举报