码迷，mamicode.com
首页 > 编程语言 > 详细

python并发_进程_multiprocessing

时间：2018-12-25 17:01:06      阅读：193      评论：0      收藏：0      [点我收藏+]

标签：label   app   阻塞   ppi   copy   apply   导致   模块   rabbit   

多进程基础, 主要是用了 multiprocessing模块 ：

在一个python进程中开启子进程，start方法和并发效果。

技术分享图片
import time
from multiprocessing import Process

def f(name):
    print(‘hello‘, name)
    print(‘我是子进程‘)

if __name__ == ‘__main__‘:
    p = Process(target=f, args=(‘bob‘,))
    p.start()
    time.sleep(1)
    print(‘执行主进程的内容了‘)
技术分享图片

 

多进程与PID

技术分享图片
# 多个进程可以同时执行  并发
# 我们现在写的一个py文件就自己一个进程  同步执行代码
# 并发效果:
    # 在我们自己的一个py文件里 启动多个进程
    # 多个进程之间 - 操作系统
# 如何在自己的py文件里 启动一个进程
import os
import time
from multiprocessing import Process
def func(args):
    print(args)
    time.sleep(1)
    print(‘子进程‘, os.getpid())
    print(‘子的父进程‘, os.getppid())
    print(‘hahaha‘)

if __name__ == ‘__main__‘: # windows下必须加这句
    print(‘父进程‘,os.getpid())
    p = Process(target=func,args=(555,))  # 注册  p 是一个进程对象  参数必须是元组
    p.start()                 # 启动一个子进程
    print(‘父父进程‘,os.getppid())  # 查看当前主进程的父过程  (当前pycharm的PID)
技术分享图片

 

老师的：http://www.cnblogs.com/Eva-J/articles/8253549.html#_label2 

 

join 感知进程结束

技术分享图片
import time
from multiprocessing import Process

def func(arg1,arg2):
    print(‘*‘*arg1)
    time.sleep(3)
    print(‘*‘*arg2)


if __name__ == ‘__main__‘:  # windows下必须加这句
    p = Process(target=func,args=(10,20))
    p.start()
    print(‘hhhhhhhh‘)
    p.join()  # 感知一个子进程的结束，将异步变为同步
    print(‘=========== 运行结束.‘)
技术分享图片

 

多个子进程写入文件：

技术分享图片
import time
import os
from multiprocessing import Process

# def func(arg1,arg2):
#     print(arg1)
#     time.sleep(2)
#     print(‘*‘*arg2)
#
#
# if __name__ == ‘__main__‘:
#     p_list = []
#     for i in range(10):
#         p = Process(target=func,args=(10*i,6*i))
#         p_list.append(p)
#         p.start()
#         # p.join()
#     [p.join() for p in p_list]
#     print(‘over.‘)



def func(filename,content):
    with open(filename,‘w‘) as f:
        f.write(str(content))


if __name__ == ‘__main__‘:   # windows下必须加这句
    p_list = []
    for i in range(1,6):   # 开5个子进程
        p = Process(target=func,args=(‘info%s‘ %i,i))
        p_list.append(p)
        p.start()

    [p.join() for p in p_list]
    # 最终每个进程写入一个文件
    print(i for i in os.walk(r‘F:\python_s9\练习\py3s9\day36 process‘))
技术分享图片

 

OOP方式 multiprocessing

技术分享图片
import time
import os
from multiprocessing import Process

# 自定义类，必须继承 Process
class MyProcess(Process):
    def run(self):   # 必须实现run方法，它是子进程中执行的代码
        print(self.pid)
        print(self.name)
        print(os.getpid())


if __name__ == ‘__main__‘:   # windows下必须加这句
    print(‘master:‘,os.getpid())
    p1 = MyProcess()
    p1.start()
    p2 = MyProcess()
    p2.start()
技术分享图片

 

技术分享图片
# 进程与进程之间 数据是完全隔离的。

import os
from multiprocessing import Process


def func():
    global n
    n =0
    print(‘pid: %s  %s‘ % (os.getpid(), n))


if __name__ == ‘__main__‘:
    n =100
    p = Process(target=func)
    p.start()
    p.join()
    print(os.getpid(),n)
技术分享图片

 

守护进程：

技术分享图片
# 子进程 -- > 守护进程
import time
from multiprocessing import Process

def func():
    while True:
        time.sleep(0.2)
        print(‘我还活着‘)

def func2():
    print(‘in func2 start‘)
    time.sleep(3)
    print(‘in func2 finished‘)

if __name__ == ‘__main__‘:
    p = Process(target=func)
    p.daemon = True   # 设置子进程为守护进程
    p.start()

    # i = 0
    # while i<5:
    #     print(‘我是socket server‘)
    #     time.sleep(1)
    #     i+=1

    p2 = Process(target=func2)
    p2.start()
    p2.terminate()     # 结束一个子进程
    time.sleep(1)
    print(p2.is_alive())  # 检验一个进程是否还活着
    print(p2.name)

# 守护进程 会 随着 主进程的代码执行完毕 而 结束
# 在主进程内结束一个子进程 p.terminate()
    #  结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程
# 检验一个进程是否活着的状态 p.is_alive()
# p.name p.pid 这个进程的名字和进程号
技术分享图片

 

进程锁： lock.acquire()

技术分享图片
# 进程锁  只在多进程时使用

# 火车票
import json
import time
from multiprocessing import Process
from multiprocessing import Lock


# def show(i):
#     with open(‘ticket‘) as f:
#         dic = json.load(f)
#     print(‘余票: %s‘%dic[‘ticket‘])

def buy_ticket(i,lock):
    lock.acquire()      # 进程锁
    with open(‘ticket‘) as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic[‘ticket‘] > 0 :
        dic[‘ticket‘] -= 1
        print(‘\033[32m%s买到票了\033[0m‘%i)
    else:
        print(‘\033[31m%s没买到票\033[0m‘%i)
    time.sleep(0.1)
    with open(‘ticket‘,‘w‘) as f:
        json.dump(dic,f)
    lock.release()      # 释放锁

if __name__ == ‘__main__‘:
    # for i in range(10):
    #     p = Process(target=show,args=(i,))
    #     p.start()
    lock = Lock()   # 实例化锁
    for i in range(10):
        p = Process(target=buy_ticket, args=(i,lock))
        p.start()
技术分享图片

ticket文件中只有：

{"ticket": 2}

 

来自 http://www.cnblogs.com/Eva-J/articles/8253549.html#_label2

 

多进程复习：

技术分享图片
# 多进程代码
# from multiprocessing import Process
# 方法
    # 进程对象.start()     开启一个子进程
    # 进程对象.join()      感知一个子进程的结束
    # 进程对象.terminate() 结束一个子进程
    # 进程对象.is_alive()  查看某个子进程是否还在运行
# 属性
    # 进程对象.name        进程名
    # 进程对象.pid         进程号
    # 进程对象.daemon      值为True的时候,表示新的子进程是一个守护进程
            # 守护进程 随着主进程代码的执行结束而结束
            # 一定在start之前设置


# from multiprocessing import Lock
# l = Lock()
# l.acquire()   # 拿钥匙
# 会造成数据不安全的操作
# l.release()   # 还钥匙
技术分享图片

 

子进程不能 input

技术分享图片
from multiprocessing import Process
def func():
    num = input(‘>>>‘)  # 子进程中不能 input 原因是主进程不能感知子进程的输入
    print(num)

if __name__ == ‘__main__‘:
    Process(target=func).start()
技术分享图片

 

信号量：Semaphore

技术分享图片
# 多进程中的组件
# ktv
# 4个
# 一套资源  同一时间 只能被n个人访问
# 某一段代码 同一时间 只能被n个进程执行

import time
import random
from multiprocessing import Process, Semaphore

# sem = Semaphore(4)
# sem.acquire()
# print(‘拿到第一把钥匙‘)
# sem.acquire()
# print(‘拿到第二把钥匙‘)
# sem.acquire()
# print(‘拿到第三把钥匙‘)
# sem.acquire()
# print(‘拿到第四把钥匙‘)
# sem.acquire()
# print(‘拿到第五把钥匙‘)


def ktv(i,sem):
    sem.acquire()
    print(‘%s 走进ktv‘ %i)
    time.sleep(random.randint(1,5))
    print(‘%s 离开‘ %i)
    sem.release()


if __name__ == ‘__main__‘:
    sem = Semaphore(4)  # 信号量4个
    for i in range(20):
        p = Process(target=ktv,args=(i,sem))
        p.start()

# 用锁的原理实现的,内置了一个计数器
# 在同一时间 只能有指定数量的进程执行某一段被控制住的代码
技术分享图片

 

 事件：

技术分享图片
# 通过一个信号 来控制 多个进程 同时 执行或者阻塞
# 事件
from multiprocessing import Event

# 一个信号可以使所有的进程都进入阻塞状态
# 也可以控制所有的进程解除阻塞
# 一个事件被创建之后,默认是阻塞状态

# e = Event()  # 创建了一个事件
# print(e.is_set())   # 查看一个事件的状态,默认被设置成阻塞
# e.set()      # 将这个事件的状态改为True
# print(e.is_set())
# e.wait()     # 是依据e.is_set()的值来决定是否阻塞的
# print(123456)
# e.clear()    # 将这个事件的状态改为False
# print(e.is_set())
# e.wait()     # 等待 事件的信号被变成True
# print(‘*‘*10)

# set 和 clear
#  分别用来修改一个事件的状态 True或者False
# is_set 用来查看一个事件的状态
# wait 是依据事件的状态来决定自己是否在wait处阻塞
#  False阻塞 True不阻塞


# 红绿灯事件
import time
import random
from multiprocessing import Event,Process

def cars(e,i):
    if not e.is_set():
        print(‘car%i在等待‘%i)
        e.wait()    # 阻塞 直到得到一个 事件状态变成 True 的信号
    print(‘\033[0;32;40mcar%i通过\033[0m‘ % i)

def light(e):
    while True:
        if e.is_set():
            e.clear()
            print(‘\033[31m红灯亮了\033[0m‘)
        else:
            e.set()
            print(‘\033[32m绿灯亮了\033[0m‘)
        time.sleep(2)

if __name__ == ‘__main__‘:
    e = Event()
    traffic = Process(target=light,args=(e,))
    traffic.start()
    for i in range(20):
        car = Process(target=cars, args=(e,i))
        car.start()
        time.sleep(random.random())
技术分享图片

 

 

进程间通信——队列和管道（multiprocess.Queue、multiprocess.Pipe）

IPC(Inter-Process Communication) 进程间通信

队列

技术分享图片
# 队列 先进先出
# IPC  # 进程间通信
# from multiprocessing import Queue
# q = Queue(5)
# q.put(1)
# q.put(2)
# q.put(3)
# q.put(4)
# q.put(5)
# print(q.full())   # 队列是否满了
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.empty())
# while True:
#     try:
#         q.get_nowait()
#     except:
#         print(‘队列已空‘)
#         time.sleep(0.5)
# for i in range(6):
#     q.put(i)

from multiprocessing import Queue,Process
def produce(q):
    q.put(‘hello‘)

def consume(q):
    print(q.get())

if __name__ == ‘__main__‘:
    q = Queue()
    p = Process(target=produce,args=(q,))
    p.start()
    c = Process(target=consume, args=(q,))
    c.start()

# put  当队列满的时候阻塞等待队列有空位置
# get  当队列空的时候阻塞等待队列有数据
# full empty 这些判断不完全准确
技术分享图片

 Kafka, rabbitMQ, memcache 等消息中间件本质上都是一种队列。

生产者 消费者 模型

技术分享图片
# 队列
# 生产者消费者模型

# 生产者 进程
# 消费者 进程
import time
import random
from multiprocessing import Process,Queue
def consumer(q,name):
    while True:
        food = q.get()
        if food is None:
            print(‘%s获取到了一个空‘%name)
            break
        print(‘\033[31m%s消费了%s\033[0m‘ % (name,food))
        time.sleep(random.randint(1,3))

def producer(name,food,q):
    for i in range(4):
        time.sleep(random.randint(1,3))
        f = ‘%s生产了%s%s‘%(name,food,i)
        print(f)
        q.put(f)

if __name__  == ‘__main__‘:
    q = Queue(20)
    p1 = Process(target=producer,args=(‘Egon‘,‘包子‘,q))
    p2 = Process(target=producer, args=(‘Bob‘,‘油条‘, q))
    c1 = Process(target=consumer, args=(q,‘Celen‘))
    c2 = Process(target=consumer, args=(q,‘Jerry‘))
    p1.start()
    p2.start()
    c1.start()
    c2.start()
    p1.join()   # 感知进程的结束
    p2.join()
    q.put(None)
    q.put(None)
技术分享图片

 

JoinableQueue 更好的方式，创建生产者消费者模型：

技术分享图片
import time
import random
from multiprocessing import Process,JoinableQueue

def consumer(q,name):
    while True:  # 取不到数据一直阻塞
        food = q.get()
        print(‘\033[31m%s消费了%s\033[0m‘ % (name,food))
        time.sleep(random.randint(1,3))
        q.task_done()     # count - 1

def producer(name,food,q):
    for i in range(4):
        time.sleep(random.randint(1,3))
        f = ‘%s生产了%s%s‘%(name,food,i)
        print(f)
        q.put(f)
    q.join()    # 阻塞  直到一个队列中的所有数据 全部被处理完毕, 进程才会结束
    # 只有 JoinableQueue 的 q 才能有此功能

if __name__  == ‘__main__‘:
    q = JoinableQueue(20)  # 使用更高级的方式代替Queue
    p1 = Process(target=producer,args=(‘生产部‘,‘PCB‘,q))
    p2 = Process(target=producer, args=(‘研发部‘,‘主机‘, q))
    c1 = Process(target=consumer, args=(q,‘Jerry‘))
    c2 = Process(target=consumer, args=(q,‘Tom‘))
    p1.start()
    p2.start()
    c1.daemon = True   # 设置为守护进程 主进程中的代码执行完毕之后,子进程自动结束
    c2.daemon = True
    c1.start()
    c2.start()
    p1.join()
    p2.join()      # 感知一个进程的结束

###　执行过程：
#  在消费者这一端:
    # 每次获取一个数据
    # 处理一个数据
    # 发送一个记号 : 标志一个数据被处理成功

# 在生产者这一端:
    # 每一次生产一个数据,
    # 且每一次生产的数据都放在队列中
    # 在队列中刻上一个记号
    # 当生产者全部生产完毕之后,
    # join信号 : 已经停止生产数据了
                # 且要等待之前被刻上的记号都被消费完
                # 当数据都被处理完时,join阻塞结束

# consumer 中把所有的任务消耗完
# producer 端 的 join感知到,停止阻塞
# 所有的producer进程结束
# 主进程中的p.join结束
# 主进程中代码结束
# 守护进程(消费者的进程)结束
# get task_done
# put join
技术分享图片

 

 管道：

技术分享图片
from multiprocessing import Pipe,Process

## 例一：
# con1,con2 = Pipe() # 一个管道两个口
# con1.send(‘32222‘) # 管道的一头发送
# print(con2.recv()) # 另一头接收


## 例二：
# def demo(conn):
#     conn.send(‘are you ok?‘)
#
# if __name__ == ‘__main__‘:
#     conn1,conn2 = Pipe()
#     Process(target=demo,args=(conn1,)).start()
#     print(‘conn2 recv:‘, conn2.recv())  # 接收也不必写长度，不会黏包


## 例三：
# def demo(conn):
#     while 1:   # 一直接收
#         msg = conn.recv()
#         if msg is None:break
#         print(msg)
#
# if __name__ == ‘__main__‘:
#     conn1,conn2 = Pipe()
#     Process(target=demo,args=(conn1,)).start()
#     for i in range(20):
#         conn2.send(‘这是测试‘)  # 发送完会阻塞
#     conn2.send(None)    # 发送结束符号


## 例四：
def func(conn1,conn2):
    conn2.close()     # 子进程管道关闭不会影响主进程
    while True:
        try :
            msg = conn1.recv()
            print(‘conn1:‘, msg)
        except EOFError:  # 没数据可取时，主动抛出的异常
            conn1.close()
            break

if __name__ == ‘__main__‘:
    conn1, conn2 = Pipe()
    Process(target=func,args = (conn1,conn2)).start()
    conn1.close()    # 主进程的管道关闭不会影响子进程
    for i in range(20):
        conn2.send(‘吃了么‘)
    conn2.close()  # 发送完成后关闭
技术分享图片

管道实现 生产者、消费者模型

技术分享图片
import time
import random

# from multiprocessing import Pipe,Process
#
# def producer(con,pro,name,food):
#     con.close()
#     for i in range(4):
#         time.sleep(random.randint(1, 3))
#         f = ‘%s生产%s%s‘%(name,food,i)
#         print(f)
#         pro.send(f)
#     pro.close()
#
# def consumer(con,pro,name):
#     pro.close()
#     while True:
#         try:
#             food = con.recv()
#             print(‘%s吃了%s‘ % (name, food))
#             time.sleep(random.randint(1,3))
#         except EOFError:
#             con.close()
#             break
#
# # 简单的一对一
# if __name__ == ‘__main__‘:
#     con,pro = Pipe()
#     p = Process(target=producer,args=(con,pro,‘Jinhua‘,‘火腿‘))
#     p.start()
#     c = Process(target=consumer, args=(con, pro, ‘Lin‘))
#     c.start()
#     con.close()
#     pro.close()


from multiprocessing import Pipe,Process,Lock
def producer(con,pro,name,food):
    con.close()
    for i in range(100):
        f = ‘%s生产%s%s‘%(name,food,i)
        print(f)
        pro.send(f)
    pro.send(None)
    pro.send(None)
    pro.send(None)
    pro.close()

def consumer(con,pro,name,lock):
    pro.close()
    while True:
        lock.acquire()    # 加锁 避免多个进程拿同一个数据
        food = con.recv()
        lock.release()
        if food is None:
            con.close()
            break
        print(‘%s吃了%s‘ % (name, food))


if __name__ == ‘__main__‘:
    con,pro = Pipe()
    lock= Lock()
    p = Process(target=producer,args=(con,pro,‘Jinhua‘,‘火腿‘))
    c1 = Process(target=consumer, args=(con, pro, ‘Lin‘,lock))
    c2 = Process(target=consumer, args=(con, pro, ‘Wang‘,lock))
    c3 = Process(target=consumer, args=(con, pro, ‘Zhao‘,lock))
    c1.start()
    c2.start()
    c3.start()
    p.start()
    con.close()
    pro.close()


# pipe 数据不安全性
# IPC
# 加锁来控制操作管道的行为 来避免多个进程之间争抢数据造成的数据不安全现象

# 队列 进程之间数据安全的
# 队列 = 管道 + 锁
# 所以，用队列比较方便，管道是更底层的，还需要自己加锁
技术分享图片

 

进程间的数据共享  Manager

技术分享图片
# from multiprocessing import Manager,Process

# def main(dic):
#     dic[‘count‘] -= 1
#     print(dic)
#
# if __name__ == ‘__main__‘:
#     m = Manager()
#     dic=m.dict({‘count‘:100})
#     p_lst = []
#     p = Process(target=main, args=(dic,))
#     p.start()
#     p.join()
#     print(‘主进程‘, dic)


from multiprocessing import Manager,Process,Lock

def main(dic,lock):
    lock.acquire()
    dic[‘count‘] -= 1
    lock.release()


if __name__ == ‘__main__‘:
    m = Manager()   # 进程间的数据共享
    l = Lock()
    dic=m.dict({‘count‘:100})
    p_lst = []
    for i in range(50):
        p = Process(target=main,args=(dic,l))
        p.start()
        p_lst.append(p)
    for i in p_lst: i.join()  # 等待子进程结束
    print(‘主进程‘,dic)
技术分享图片

 

进程池

技术分享图片
# 为什么会有进程池的概念
    # 效率
    # 每开启进程,开启属于这个进程的内存空间
    # 寄存器 堆栈 文件
    # 进程过多 操作系统的调度

# 进程池
    # python中的 先创建一个属于进程的池子
    # 这个池子指定能存放n个进程
    # 先将这些进程创建好  进程超过5个建议使用进程池

# 更高级的进程池 比如动态增加的 python中没有
    # n,m
    # 3   三个进程
    #     + 进程
    # 20  20个


# import time
# from multiprocessing import Pool,Process
# def func(n):
#     for i in range(5):
#         print(n+1)
#
# if __name__ == ‘__main__‘:
#     pool = Pool(5)              # 5个进程
#     pool.map(func,range(100))    # 100个任务


import time
from multiprocessing import Pool,Process
def func(n):
    for i in range(10):
        print(n+1)

if __name__ == ‘__main__‘:
    start = time.time()
    pool = Pool(5)               # 5个进程
    pool.map(func,range(100))    # 100个任务
    t1 = time.time() - start

    start = time.time()
    p_lst = []
    for i in range(100):
        p = Process(target=func,args=(i,))
        p_lst.append(p)
        p.start()
    for p in p_lst :p.join()
    t2 = time.time() - start
    print(t1,t2)

## 进程池的好处就是用少的进程干更多的活。一般创建CPU+1个进程

# import time
# from multiprocessing import Pool,Process
# def func(n):
#     for i in range(10):
#         print(n+1)
#
# def func2(n):
#     n[0]
#     n[1]
#     for i in range(10):
#         print(n+2)

# if __name__ == ‘__main__‘:
#     start = time.time()
#     pool = Pool(5)               # 5个进程
#     pool.map(func,range(100))    # 100个任务
#     pool.map(func2,[(‘alex‘,1),‘egon‘]) # map第二个参数必须是可迭代, 异步且自带join方法
#     t1 = time.time() - start
#
#     start = time.time()
#     p_lst = []
#     for i in range(100):     # 起100个进程的时候，效率反而降低了。
#         p = Process(target=func,args=(i,))
#         p_lst.append(p)
#         p.start()
#     for p in p_lst :p.join()
#     t2 = time.time() - start
#     print(t1,t2)
技术分享图片

 

进程池中的 apply_async 异步执行

技术分享图片
import os
import time
from multiprocessing import Pool

def func(n):
    print(‘start func%s‘%n,os.getpid())
    time.sleep(1)
    print(‘end func%s‘ % n,os.getpid())

if __name__ == ‘__main__‘:
    p = Pool(5)   # 一般起cpu +1 个进程
    for i in range(10):
        # p.apply(func,args=(i,))       # 同步方式执行
        p.apply_async(func,args=(i,))   # 异步
    p.close()  # 结束进程池接收任务
    p.join()   # 感知进程池中的任务执行结束
技术分享图片

 

进程池的返回值 

技术分享图片
# p = Pool()
# p.map(funcname,iterable)   默认异步的执行任务,且自带close和join
# p.apply    同步调用的
# p.apply_async 异步调用 和主进程完全异步 需要手动close 和 join


# from multiprocessing import Pool
#
# def func(i):
#     return i**2
#
# if __name__ == ‘__main__‘:
#     p = Pool(5)
#     for i in range(10):
#         res = p.apply(func,args=(i,))
#         print(res)     # apply的结果就是func的返回值


# import time
# from multiprocessing import Pool
#
# def func(i):
#     time.sleep(0.5)
#     return i*i
#
# if __name__ == ‘__main__‘:
#     p = Pool(5)
#     for i in range(10):
#         res = p.apply_async(func,args=(i,))   # apply的结果就是func的返回值
#         print(res.get())      # get 等着 func的计算结果 导致阻塞


# import time
# from multiprocessing import Pool
#
# def func(i):
#     time.sleep(0.5)
#     return i*i
#
# if __name__ == ‘__main__‘:
#     p = Pool(5)
#     res_l = []
#     for i in range(10):
#         res = p.apply_async(func,args=(i,))   # apply的结果就是func的返回值
#         res_l.append(res)
#     for res in res_l:print(res.get())    # 每组5个出现


import time
from multiprocessing import Pool
def func(i):
    time.sleep(0.5)
    return i*i

if __name__ == ‘__main__‘:
    p = Pool(5)
    ret = p.map(func,range(10))  # map 自带join 和 close
    print(ret)      # 得到list
技术分享图片

 

进程池的回调函数

技术分享图片
# 回调函数
# import os
# from multiprocessing import Pool
#
# def func1(n):
#     print(‘in func1‘,os.getpid())
#     return n*n
#
# def func2(nn):
#     print(‘in func2‘,os.getpid())
#     print(‘func2 res:‘, nn)
#
# if __name__ == ‘__main__‘:
#     print(‘主进程 :‘,os.getpid())
#     p = Pool(5)
#     p.apply_async(func1,args=(10,),callback=func2)  # 回到主进程中执行
#     p.close()
#     p.join()



import os
from multiprocessing import Pool

def func1(n):
    print(‘in func1‘,os.getpid())
    return n*n

def func2(nn):
    print(‘in func2‘,os.getpid())
    print(‘f2 结果:‘, nn)

if __name__ == ‘__main__‘:
    print(‘主进程 :‘,os.getpid())
    p = Pool(5)
    for i in range(10):  # 多个子进程
        p.apply_async(func1,args=(10,),callback=func2)
    p.close()
    p.join()
技术分享图片

python并发_进程_multiprocessing

标签：label   app   阻塞   ppi   copy   apply   导致   模块   rabbit   

原文地址：https://www.cnblogs.com/FHBIAO/p/10174532.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！