python学习笔记-（十四）进程&协程

一. 进程

1. 多进程multiprocessing

multiprocessing包是Python中的多进程管理包，是一个跨平台版本的多进程模块。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法类似。

创建一个Process实例，可用start()方法启动。

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

from multiprocessing import Process
import time
def f(name):
    time.sleep(2)
    print(‘hello‘, name)

if __name__ == ‘__main__‘:
    p = Process(target=f, args=(‘bob‘,))
    p.start()
    p.join()

写个程序，对比下主进程和子进程的ID：

from multiprocessing import Process
import os
def info(title):
    print(title)
    print(‘进程名称:‘, __name__)
    print(‘父进程ID:‘, os.getppid())
    print(‘子进程ID:‘, os.getpid())
    print("\n\n")
def f(name):
    info(‘\033[31;1mcalled from child process function f\033[0m‘)
    print(‘hello‘, name)
if __name__ == ‘__main__‘:
    info(‘\033[32;1mmain process line\033[0m‘)
    p = Process(target=f, args=(‘bob‘,))
    p.start()

2. 进程间通信

不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以使用Queue、Pipe、Manager，其中：

1）Queue  \ Pipe 只是实现进程间数据的传递；

2）Manager 实现了进程间数据的共享，即多个进程可以修改同一份数据；

2.1 Queue

Queue允许多个进程放入，多个进程从队列取出对象，先进先出。（使用方法跟threading里的queue差不多）

from multiprocessing import Process,Queue
def f(qq):
    qq.put([42,None,"hello"])
    qq.put([43,None,"HI"])

if __name__ == ‘__main__‘:
    q = Queue()
    p = Process(target=f,args=(q,))
    p.start()
    print(q.get())
    print(q.get())
    p.join()

2.2 Pipe

Pipe也是先进先出

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, ‘儿子发送的消息‘])
    conn.send([42, None, ‘儿子又发消息啦‘])
    print("接收父亲的消息:",conn.recv())
    conn.close()

if __name__ == ‘__main__‘:
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())  # prints "[42, None, ‘hello‘]"
    print(parent_conn.recv())  # prints "[42, None, ‘hello‘]"
    parent_conn.send("回家吃饭！") # prints "[42, None, ‘hello‘]"
    p.join()

2.3 Manager

Manager对象类似于服务器与客户之间的通信 (server-client)，与我们在Internet上的活动很类似。我们用一个进程作为服务器，建立Manager来真正存放资源。其它的进程可以通过参数传递或者根据地址来访问Manager，建立连接后，操作服务器上的资源。在防火墙允许的情况下，我们完全可以将Manager运用于多计算机，从而模仿了一个真实的网络情境。

from multiprocessing import Process,Manager
import  os
def f(d,l):
    d[os.getpid()] = os.getpid()
    l.append(os.getpid())
    print(l)

if __name__ == "__main__":
    with Manager() as manager:
        d = manager.dict()#生成一个字典，可在多个进程间共享和传递
        l = manager.list(range(5))#生成一个列表，可在多个进程间实现共享和传递
        p_list = []
        for i in range(10):
            p = Process(target=f,args=(d,l))
            p.start()
            p_list.append(p)
        for res in p_list:#等待结果
            res.join()

3. 进程池

进程池 (Process Pool)可以创建多个进程。这些进程就像是随时待命的士兵，准备执行任务(程序)。一个进程池中可以容纳多个待命的士兵。

进程池有两种方法：

1）串行：apply

2）并行：apply_async

from multiprocessing import Process,Pool
import time
import os
def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
    return i+100
def Bar(arg):
    ‘‘‘回调函数‘‘‘
    print("-->>exec done:",arg,os.getpid())
if __name__ == "__main__":
    pool = Pool(processes=3)#允许进程池同时放入3个进程
    print("主进程",os.getpid())
    for i in range(10):
        pool.apply_async(func=Foo,args=(i,),callback=Bar)
    print(‘end‘)
    pool.close()
    pool.join()#进程池中进程执行完毕后在关闭；如果注释则程序直接关闭

使用回调函数的目的是：在父进程中执行可以提高效率；（比如连接数据库，写回调函数的话，父进程连接一次数据库即可；如果使用子进程，则需要连接多次）

4. 其他(lock)

lock：屏幕上打印的锁，防止打印显示混乱

from multiprocessing import Process, Lock
def f(l, i):
    #上锁
    l.acquire()
    try:
        print(‘hello world‘, i)
    finally:
        #解锁
        l.release()

#因为屏幕是共享的，定义锁的目的是打印的信息不换乱，而不是顺序不会乱
if __name__ == ‘__main__‘:
    #定义锁
    lock = Lock()
    for num in range(10):
        Process(target=f, args=(lock, num)).start()

二. 协程

协程，又称微线程，纤程。英文名Coroutine。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

好处：

  • 无需线程上下文切换的开销
  • 无需原子操作锁定及同步的开销
  • 方便切换控制流，简化编程模型
  • 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点：

  • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
  • 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

1.实例

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

代码示例：

def consumer():
    r = ‘‘
    while True:
        n = yield r
        if not n:
            return
        print(‘[消费者] Consuming %s...‘ % n)
        r = ‘200 OK‘
def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print(‘[生产者] Producing %s...‘ % n)
        r = c.send(n)
        print(‘[生产者] 消费者返回状态码: %s‘ % r)
    c.close()

c = consumer()
produce(c)

输出结果：

[生产者] Producing 1...
[消费者] Consuming 1...
[生产者] 消费者返回状态码: 200 OK
[生产者] Producing 2...
[消费者] Consuming 2...
[生产者] 消费者返回状态码: 200 OK
[生产者] Producing 3...
[消费者] Consuming 3...
[生产者] 消费者返回状态码: 200 OK
[生产者] Producing 4...
[消费者] Consuming 4...
[生产者] 消费者返回状态码: 200 OK
[生产者] Producing 5...
[消费者] Consuming 5...
[生产者] 消费者返回状态码: 200 OK

注意到consumer函数是一个generator，把一个consumer传入produce后：

  1. 首先调用c.send(None)启动生成器；
  2. 然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
  3. consumer通过yield拿到消息，处理，又通过yield把结果传回；
  4. produce拿到consumer处理的结果，继续生产下一条消息；
  5. produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

整个流程无锁，由一个线程执行，生产者和消费者协作完成任务，所以称为“协程”，而非线程的抢占式多任务。（原理：遇到I/O操作就切换，只剩下CPU操作（CPU操作非常快））

一句话总结协程的特点：子程序就是协程的一种特例。

python中支持协程的有以下两个模块：greenlet和greent

2. Greenlet

greenlet封装好的协程,利用.swith对协程操作进行手动切换

from greenlet import  greenlet
def test1():
    print(12)
    gr3.switch()
    print(34)
    gr2.switch()
    print(78)
def test2():
    print(56)
    gr1.switch()
def test3():
    print(90)
    gr1.switch()
gr1 = greenlet(test1)#启动协程
gr2 = greenlet(test2)
gr3 = greenlet(test3)
gr1.switch()

3. Greent

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

import gevent
def foo():
    print("运行foo")
    gevent.sleep(2)
    print("再次回到foo")
def bar():
    print("这里是bar")
    gevent.sleep(1)
    print("又回到了bar")
def func3():
    print("运行func3")
    gevent.sleep(0)
    print("再次运行func3")
gevent.joinall([
    gevent.spawn(foo),
    gevent.spawn(bar),
    gevent.spawn(func3)
])

同步与异步的性能区别：

1）同步：

from gevent import monkey;

# monkey.patch_all()
import gevent
from  urllib.request import urlopen
import time

def f(url):
    print(‘GET: %s‘ % url)
    resp = urlopen(url)
    data = resp.read()
    print(‘%d bytes received from %s.‘ % (len(data), url))

urls = [ ‘https://www.python.org/‘,
         ‘https://www.yahoo.com/‘,
         ‘https://github.com/‘
         ]

time_start = time.time()
for url in urls:
    f(url)
print("同步cost",time.time() - time_start)

2）异步：

from gevent import monkey;

# monkey.patch_all()
import gevent
from  urllib.request import urlopen
import time

def f(url):
    print(‘GET: %s‘ % url)
    resp = urlopen(url)
    data = resp.read()
    print(‘%d bytes received from %s.‘ % (len(data), url))

urls = [ ‘https://www.python.org/‘,
         ‘https://www.yahoo.com/‘,
         ‘https://github.com/‘
         ]
async_time_start = time.time()
gevent.joinall([
    gevent.spawn(f, ‘https://www.python.org/‘),
    gevent.spawn(f, ‘https://www.yahoo.com/‘),
    gevent.spawn(f, ‘https://github.com/‘),
])
print("异步cost",time.time()-async_time_start )

结论：同步开销时间为4秒，异步开销为2.5秒，大大节省了开销，这就是协程的魅力；monkey.patch_all()使gevent能识别到urllib中的I/O操作

使用gevent实现单线程下的多socket并发：

import sys
import socket
import time
import gevent

from gevent import socket,monkey
monkey.patch_all()

def server(port):
    s = socket.socket()
    s.bind((‘0.0.0.0‘, port))
    s.listen(500)
    while True:
        cli, addr = s.accept()
        gevent.spawn(handle_request, cli)

def handle_request(conn):
    try:
        while True:
            data = conn.recv(1024)
            print("recv:", data)
            conn.send(data)
            if not data:
                conn.shutdown(socket.SHUT_WR)

    except Exception as  ex:
        print(ex)
    finally:
        conn.close()
if __name__ == ‘__main__‘:
    server(8001)

server端

import socket

HOST = ‘localhost‘    # The remote host
PORT = 8001           # The same port as used by the server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while True:
    msg = bytes(input(">>:"),encoding="utf8")
    s.sendall(msg)
    data = s.recv(1024)
    #print(data)

    print(‘Received‘, repr(data))
s.close()

client端

时间： 2024-10-22 16:57:06

python学习笔记-（十四）进程&协程的相关文章

python学习笔记(十四) - easy_install安装与使用

一. 背景知识 在使用python的时候,经常会使用到本身没有安装的第三方模块,这时我们就需要使用easy_install 二. 使用方法 1. 下载easy_setup.py的源代码:http://pypi.python.org/pypi/setuptools 2. 用记事本存放源码并命令为easy_setup.py 3. 双击运行或在命令行运行:python easy_setup.py 4. 在python的安装目录python\scripts目录中可以看到有好几个easy_install的

python学习笔记(十四): unittest

Python中有一个自带的单元测试框架是unittest模块,用它来做单元测试,它里面封装好了一些校验返回的结果方法和一些用例执行前的初始化操作. 在说unittest之前,先说几个概念: TestCase 也就是测试用例 TestSuite 多个测试用例集合在一起,就是TestSuite TestLoader是用来加载TestCase到TestSuite中的 TestRunner是来执行测试用例的,测试的结果会保存到TestResult实例中,包括运行了多少测试用例,成功了多少,失败了多少等信

python学习笔记十——异常处理

1.try: command except 错误类型,记录错误信息变量: command finally: command try...finally的用处是无论是否发生异常都要确保资源释放代码的执行.一般来说,如果没有发生错误,执行过try语句块之后执行finally语句块,完成整个流程.如果try语句块发生了异常,抛出了这个异常,此时就马上进入finally语句块进行资源释放处理.如下从几个细节讨论finally的特性. 1).try中的return: 当在try语句块中含有return语句

Swift学习笔记十四：构造（Initialization）

类和结构体在实例创建时,必须为所有存储型属性设置合适的初始值.存储型属性的值不能处于一个未知的状态. 你可以在构造器中为存储型属性赋初值,也可以在定义属性时为其设置默认值.以下章节将详细介绍这两种方法. 注意: 当你为存储型属性设置默认值或者在构造器中为其赋值时,它们的值是被直接设置的,不会触发任何属性观测器(property observers). 一.基本语法 class Human{ var name :String init(){ name = "human" } init(n

laravel3学习笔记(十四)

原作者博客:ieqi.net ==================================================================================================== 运行时配置 在 Laravel3 中很多地方我们都可以看到“约定大于配置”的影子,我本人也很喜欢这种工程哲学尤其是在框架领域,当然这并不能代替所有的配置.我们知道 Laravel3 中,主要配置都写在 application/config 文件夹下,在应用逻辑中,往往

python学习笔记(十) - 进程和线程

线程是最小的执行单元,而进程由至少一个线程组成.如何调度进程和线程,完全由操作系统决定,程序自己不能决定什么时候执行,执行多长时间. 一.多进程 1. multiprocessing模块时跨平台版本的多线程模块 process类代表一个进程对象,创建子进程时,只需要传入一个执行函数和函数的参数,使用start方法启动 join方法可以等待子进程结束后再继续往下运行,通常用于进程间同步. from multiprocessing import Process import os # 子进程要执行的

python第五十三天--进程,协程.select.异步I/O...

进程: 1 #!usr/bin/env python 2 #-*-coding:utf-8-*- 3 # Author calmyan 4 import multiprocessing,threading,time 5 6 def run(name): 7 t=threading.Thread(target=run2)#创建新线程 8 t.start() 9 print('进程[%s],打印中...'%name) 10 time.sleep(1) 11 12 def run2(): 13 pri

Python学习笔记（四，迭代器、生成器、内置函数）

一.迭代器 1.迭代器定义 迭代是一个重复的过程,每次重复一次迭代,并且每次迭代的结果都是下一次迭代的初始值. l = ["aaa","bbb","ccc"] count = 0 while count< len(l): #每次重复完成后count都是下一次的初始值 print(l[count]) count+=1 需要迭代器的原因:对于序列类型str.list.tuple可以依赖索引迭代取值,对于dict.set.文件需要提供不依赖索引取

Python学习笔记十_模块、第三方模块安装、模块导入

一.模块.包 1.模块 模块实质上就是一个python文件.它是用来组织代码的,意思就是把python代码写到里面,文件名就是模块的名称,test.py test就是模块的名称 2.包 包,package本质就是一个文件夹,和文件夹不一样的是它有一个__init__.py文件.包是从逻辑上来组织模块的,也就是说它是用来存放模块的,如果想到如其他目录下的模块,那么这个目录必须是一个包才可以导入. 二.模块分类 1.标准模块.标准包 python自带的这些模块,直接import就能用的 import

Python学习笔记（四十四）

摘抄自:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143200341926302f99cf6f6414dca9dfaaf6e5a25a5b1000 Tkinter 我们编写的Python代码会调用内置的Tkinter,Tkinter封装了访问Tk的接口: Tk是一个图形库,支持多个操作系统,使用Tcl语言开发: Tk会调用操作系统提供的本地GUI接口,完成最终的GUI