并发编程

最新推荐文章于 2024-04-30 19:24:04 发布

weixin_30326741

最新推荐文章于 2024-04-30 19:24:04 发布

阅读量68

点赞数

文章标签： python json

原文链接：http://www.cnblogs.com/zhao-zhao/p/11323547.html

版权

---恢复内容开始---

一、引子

1.1、python中的GIL机制与多进程

起源：GIL的存在使得python一个进程中只能有一个线程再跑，具体这样做是什么原因，我现在不清楚。但是为了能提高python的工作效率，我们可以借助模块多起进程，使进程间实现异步运行。

主进程与子进程之间不能进行数据交换：

from multiprocessing import Process,Lock
import json,time
def too():
    global n
    n=0
    print('子进程',n) if __name__ == '__main__': n=10 Process(target=too).start() print('主进程',n)

主进程 10
子进程 0

因此子进程中无法使用input来外部输入，因为你能看到的是主进程的运行。

1.1.1、multiprocessing 模块、Process、Lock

由于python只能调用一个cpu来工作，故适合用来处理IO密集型问题。

一个自定制多进程的例子

1.1.2、守护进程

守护进程会随着主进程的代码执行完毕而结束，而不是随着主进程的完毕而完毕。

就像这个样子一个例子

1.1.3、同步锁

理论：http://c.biancheng.net/view/2617.html

火车票抢票例子

1.1.4、信号量

概念：之前讲到同步锁。同步锁是每次只允许一个进程去执行被锁住的代码；而信号量提供了一种机制，可以指定个数的进程去执行被锁住的代码。

信号量semaphore

1.1.5、事件（Event）

作用：可以建立进程之间的一个联系。

基本用法

通过事件的特性，实现红灯停绿灯行

红绿灯事件

2.1、进程间通讯（IPC）

2.1.1、队列

描述：multiprocessing 提供了一个方法Queue类，通过实例的put，get方法就可用实现进程间的数据通讯。其中由于full与empty方法返回的只是查询当前的状态而不是实时状态，故使用时应考虑时间因素。

一个例子

Queue的方法

其中队列中自定义数字“5”设定的是队列的长度，put达到这个长度时将会堵塞，等待get取走有空余之后才会接着执行。这个长度对于get同样适用。

属于数据安全型。

2.1.2、生产者消费者模型

初级模型

概述：初级模型中使用了队列的方法，此方法有两个作用：1、将生产者产生的数据传到消费者；2、起到消费者与生产者之间的先后顺序的作用（如果没有put，当get时就会阻塞）。最后再通过加判断的方式，实现生产者主导消费者，当生产者进程退出时，消费者进程跟着退出。

进阶模型JoinableQueue

概述：1、引入Joinablequeue的目的：为了优化Queue方法的弊端---------队列的作用可以实现不同进程之间数据的传递，但是Queue没有提供一个进程结束后退出的功能，这个就不太符合解放人力的目的。为此引入Joinablequeue。

　　2、为实现进程结束后直接退出而不是阻塞的功能，需要解决的点在于：a、必须确保两个进程中的动作都执行完毕后再结束进程；b、如果结束进程。

　　3、实现方法：step1、将其中一个进程设置为另一个进程的守护进程（将进程B设置为进程A的守护进程）；step2、通过对B进程加task_done方法，对A进程添加join方法来实现两个进程都执行完毕后再退出（这两个方法都是在进程动作程序的末尾添加）。

2.1.3、管道

作用：实现进程间的通讯

初识Pipe

方法二

由于Pipe也存在数据不安全性，故需要对recv这步加锁。

2.1.4、Manager方法

作用：进程间通讯，但是也存在数据不安全问题。

初识Manager

2.2、进程池

作用：为弥补多进程Process引起的执行效率慢的情况，引入进程池概念。进程池是事先在池里放指定数量个进程（一般比电脑核数多一个），然后再安排进程去处理那些任务。

from multiprocessing import Pool
import time
def foo(n):
    print('start foo%s'%n)
    time.sleep(1)
    print('end foo%s'%n) if __name__ == '__main__': p=Pool(5) # 起5个进程 for i in range(50): p.apply_async(foo,args=(i,)) p.close() p.join()

Pool方法总结

from multiprocessing import Pool
# p=Pool()
# p.map(funcname,iterable) 默认为异步的执行任务，且自带close和join
# p.apply()   同步调用
# p.apply_async()  异步调用，和主进程完全异步，需要手动close和join

总结

使用进程池方法，子进程函数中可带有返回值

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res_l=[]
    for i in range(10):
        res=p.apply_async(func,args=(i,))
        res_l.append(res)
    for i in res_l:print(i.get())

apply_async方法

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res=p.map(func,range(10))
    print(res)

map方法

---恢复内容结束---

一、引子

1.1、python中的GIL机制与多进程

主进程与子进程之间不能进行数据交换：

from multiprocessing import Process,Lock
import json,time
def too():
    global n
    n=0
    print('子进程',n) if __name__ == '__main__': n=10 Process(target=too).start() print('主进程',n)

主进程 10
子进程 0

因此子进程中无法使用input来外部输入，因为你能看到的是主进程的运行。

1.1.1、multiprocessing 模块、Process、Lock

由于python只能调用一个cpu来工作，故适合用来处理IO密集型问题。

一个自定制多进程的例子

1.1.2、守护进程

守护进程会随着主进程的代码执行完毕而结束，而不是随着主进程的完毕而完毕。

一个例子

1.1.3、同步锁

理论：http://c.biancheng.net/view/2617.html

火车票抢票例子

1.1.4、信号量

概念：之前讲到同步锁。同步锁是每次只允许一个进程去执行被锁住的代码；而信号量提供了一种机制，可以指定个数的进程去执行被锁住的代码。

信号量semaphore

1.1.5、事件（Event）

作用：可以建立进程之间的一个联系。

基本用法

通过事件的特性，实现红灯停绿灯行

红绿灯事件

2.1、进程间通讯（IPC）

2.1.1、队列

一个例子

Queue的方法

其中队列中自定义数字“5”设定的是队列的长度，put达到这个长度时将会堵塞，等待get取走有空余之后才会接着执行。这个长度对于get同样适用。

属于数据安全型。

2.1.2、生产者消费者模型

初级模型

进阶模型JoinableQueue

　　2、为实现进程结束后直接退出而不是阻塞的功能，需要解决的点在于：a、必须确保两个进程中的动作都执行完毕后再结束进程；b、如果结束进程。

2.1.3、管道

作用：实现进程间的通讯

初识Pipe

方法二

由于Pipe也存在数据不安全性，故需要对recv这步加锁。

2.1.4、Manager方法

作用：进程间通讯，但是也存在数据不安全问题。

初识Manager

2.2、进程池

from multiprocessing import Pool
import time
def foo(n):
    print('start foo%s'%n)
    time.sleep(1)
    print('end foo%s'%n) if __name__ == '__main__': p=Pool(5) # 起5个进程 for i in range(50): p.apply_async(foo,args=(i,)) p.close() p.join()

Pool方法总结

from multiprocessing import Pool
# p=Pool()
# p.map(funcname,iterable) 默认为异步的执行任务，且自带close和join
# p.apply()   同步调用
# p.apply_async()  异步调用，和主进程完全异步，需要手动close和join

总结

使用进程池方法，子进程函数中可带有返回值

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res_l=[]
    for i in range(10):
        res=p.apply_async(func,args=(i,))
        res_l.append(res)
    for i in res_l:print(i.get())

apply_async方法

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res=p.map(func,range(10))
    print(res)

map方法

---恢复内容开始---

一、引子

1.1、python中的GIL机制与多进程

主进程与子进程之间不能进行数据交换：

from multiprocessing import Process,Lock
import json,time
def too():
    global n
    n=0
    print('子进程',n) if __name__ == '__main__': n=10 Process(target=too).start() print('主进程',n)

主进程 10
子进程 0

因此子进程中无法使用input来外部输入，因为你能看到的是主进程的运行。

1.1.1、multiprocessing 模块、Process、Lock

由于python只能调用一个cpu来工作，故适合用来处理IO密集型问题。

一个自定制多进程的例子

1.1.2、守护进程

守护进程会随着主进程的代码执行完毕而结束，而不是随着主进程的完毕而完毕。

一个例子

1.1.3、同步锁

理论：http://c.biancheng.net/view/2617.html

火车票抢票例子

1.1.4、信号量

概念：之前讲到同步锁。同步锁是每次只允许一个进程去执行被锁住的代码；而信号量提供了一种机制，可以指定个数的进程去执行被锁住的代码。

信号量semaphore

1.1.5、事件（Event）

作用：可以建立进程之间的一个联系。

基本用法

通过事件的特性，实现红灯停绿灯行

红绿灯事件

2.1、进程间通讯（IPC）

2.1.1、队列

一个例子

Queue的方法

其中队列中自定义数字“5”设定的是队列的长度，put达到这个长度时将会堵塞，等待get取走有空余之后才会接着执行。这个长度对于get同样适用。

属于数据安全型。

2.1.2、生产者消费者模型

初级模型

进阶模型JoinableQueue

　　2、为实现进程结束后直接退出而不是阻塞的功能，需要解决的点在于：a、必须确保两个进程中的动作都执行完毕后再结束进程；b、如果结束进程。

2.1.3、管道

作用：实现进程间的通讯

初识Pipe

方法二

由于Pipe也存在数据不安全性，故需要对recv这步加锁。

2.1.4、Manager方法

作用：进程间通讯，但是也存在数据不安全问题。

初识Manager

2.2、进程池

from multiprocessing import Pool
import time
def foo(n):
    print('start foo%s'%n)
    time.sleep(1)
    print('end foo%s'%n) if __name__ == '__main__': p=Pool(5) # 起5个进程 for i in range(50): p.apply_async(foo,args=(i,)) p.close() p.join()

Pool方法总结

from multiprocessing import Pool
# p=Pool()
# p.map(funcname,iterable) 默认为异步的执行任务，且自带close和join
# p.apply()   同步调用
# p.apply_async()  异步调用，和主进程完全异步，需要手动close和join

总结

使用进程池方法，子进程函数中可带有返回值

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res_l=[]
    for i in range(10):
        res=p.apply_async(func,args=(i,))
        res_l.append(res)
    for i in res_l:print(i.get())

apply_async方法

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res=p.map(func,range(10))
    print(res)

map方法

---恢复内容结束---

一、引子

1.1、python中的GIL机制与多进程

主进程与子进程之间不能进行数据交换：

from multiprocessing import Process,Lock
import json,time
def too():
    global n
    n=0
    print('子进程',n) if __name__ == '__main__': n=10 Process(target=too).start() print('主进程',n)

主进程 10
子进程 0

因此子进程中无法使用input来外部输入，因为你能看到的是主进程的运行。

1.1.1、multiprocessing 模块、Process、Lock

由于python只能调用一个cpu来工作，故适合用来处理IO密集型问题。

一个自定制多进程的例子

1.1.2、守护进程

守护进程会随着主进程的代码执行完毕而结束，而不是随着主进程的完毕而完毕。

一个例子

1.1.3、同步锁

理论：http://c.biancheng.net/view/2617.html

火车票抢票例子

1.1.4、信号量

概念：之前讲到同步锁。同步锁是每次只允许一个进程去执行被锁住的代码；而信号量提供了一种机制，可以指定个数的进程去执行被锁住的代码。

信号量semaphore

1.1.5、事件（Event）

作用：可以建立进程之间的一个联系。

基本用法

通过事件的特性，实现红灯停绿灯行

红绿灯事件

2.1、进程间通讯（IPC）

2.1.1、队列

一个例子

Queue的方法

其中队列中自定义数字“5”设定的是队列的长度，put达到这个长度时将会堵塞，等待get取走有空余之后才会接着执行。这个长度对于get同样适用。

属于数据安全型。

2.1.2、生产者消费者模型

初级模型

进阶模型JoinableQueue

　　2、为实现进程结束后直接退出而不是阻塞的功能，需要解决的点在于：a、必须确保两个进程中的动作都执行完毕后再结束进程；b、如果结束进程。

2.1.3、管道

作用：实现进程间的通讯

初识Pipe

方法二

由于Pipe也存在数据不安全性，故需要对recv这步加锁。

2.1.4、Manager方法

作用：进程间通讯，但是也存在数据不安全问题。

初识Manager

2.2、进程池

from multiprocessing import Pool
import time
def foo(n):
    print('start foo%s'%n)
    time.sleep(1)
    print('end foo%s'%n) if __name__ == '__main__': p=Pool(5) # 起5个进程 for i in range(50): p.apply_async(foo,args=(i,)) p.close() p.join()

Pool方法总结

from multiprocessing import Pool
# p=Pool()
# p.map(funcname,iterable) 默认为异步的执行任务，且自带close和join
# p.apply()   同步调用
# p.apply_async()  异步调用，和主进程完全异步，需要手动close和join

总结

使用进程池方法，子进程函数中可带有返回值

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res_l=[]
    for i in range(10):
        res=p.apply_async(func,args=(i,))
        res_l.append(res)
    for i in res_l:print(i.get())

apply_async方法

from multiprocessing import Pool
import time
def func(i):
    time.sleep(1)
    return i*i
if __name__ == '__main__':
    p=Pool(5)
    res=p.map(func,range(10))
    print(res)

map方法

转载于:https://www.cnblogs.com/zhao-zhao/p/11323547.html

weixin_30326741

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发编程

---恢复内容开始---一、引子1.1、python中的GIL机制与多进程起源：GIL的存在使得python一个进程中只能有一个线程再跑，具体这样做是什么原因，我现在不清楚。但是为了能提高python的工作效率，我们可以借助模块多起进程，使进程间实现异步运行。主进程与子进程之间不能进行数据交换：from multiprocessing import Process...
复制链接

扫一扫