python多进程中常用方法用法详解

1、进程间的通信

        全局变量在多个进程中不共享资源,进程之间的数据是独立的,默认情况下是互不影响的。

示例代码:

from multiprocessing import Process

num = 1


def task1():
    global num
    num += 5
    print("子进程1运行,num:", num)


def task2():
    global num
    num += 10
    print("子进程2运行,num:", num)


if __name__ == '__main__':
    print("父进程开始运行...")
    p1 = Process(target=task1)
    p2 = Process(target=task2)
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行结果:

2、用 Queue() 实现多进程之间的数据传递

        Queue 是多进程安全的队列,可以使用 Queue 实现多进程之间的数据传递。

        put 方法用以插入数据到队列中, put 方法还有两个可选参数: blocked 和 timeout。如果 blocked 为 True(默认值),并且 timeout 为正值,该方法会阻塞 timeout 指定的时间,直到该队列有剩余的空间。如果超时,会抛出 Queue.full 异常。如果 blocked 为 False,但该 Queue 已满,会立即抛出 Queue.full 异常。

        get 方法可以从队列读取并且删除一个元素。同样, get 方法有两个可选参数: blocked和 timeout。如果 blocked 为 True(默认值),并且 timeout 为正值,那么在等待时间内没有取到任何元素,会抛出 Queue.Empty 异常。如果 blocked 为 False,有两种情况存在,如果Queue 有一个值可用,则立即返回该值,否则,如果队列为空,则立即抛出Queue.Empty 异常

示例代码:

from multiprocessing import Queue


q = Queue(3)
q.put('msg1')
q.put('msg2')
print('消息队列是否已满:', q.full())
q.put('msg3')
print('消息队列是否已满:', q.full())
# q.put('msg4')  # 以为消息队列已经满了,需要直接写入需要等待,如果超时会抛出异常

# 写入数据时先判断,判断队列是否已满
if not q.full():
    q.put('msg4')

# 同理,取消息时可以先判断队列是否有数据
if not q.empty():
    for _ in range(q.qsize()):
        print(q.get())

运行结果:

示例代码:

from multiprocessing import Process
from multiprocessing import Queue
import random
import os


# 向queue中输入数据的函数
def inputQ(queue):
    info = random.randint(1, 100)
    queue.put(info)
    print('进程{}往队列中存了一个数据:{}'.format(os.getpid(), info))


# 向queue中输出数据的函数
def outputQ(queue):
    info = queue.get()
    print('进程{}从队列中取出一个数据:{}'.format(os.getpid(), info))


if __name__ == '__main__':

    queue = Queue(5)
    lst_1 = []
    lst_2 = []
    for i in range(3):
        process = Process(target=inputQ, args=(queue,))
        process.start()
        lst_1.append(process)

    # 输出进程
    for i in range(2):
        process = Process(target=outputQ, args=(queue,))
        process.start()
        lst_2.append(process)

    for p in lst_1:
        p.join()

    for p in lst_2:
        p.join()

运行结果:

3、Queue 队列实现进程间通信

示例代码:

import time
from multiprocessing import Queue, Process


def write_data(q):
    # 将列表元素写入到队列中
    for i in ['aa', 'bb', 'cc', 'dd']:
        print('开始写入值%s' %i)
        q.put(i)
        time.sleep(1)


def read_data(q):
    print("开始读取数据...")
    while True:
        if not q.empty():
            print("读取到数据:", q.get())
            time.sleep(1)
        else:
            break


if __name__ == '__main__':
    # 创建队列
    q = Queue()
    # 创建进程
    qw = Process(target=write_data, args=(q, ))
    qr = Process(target=read_data, args=(q, ))

    # 启动进程
    qw.start()
    qr.start()
    qw.join()
    qr.join()

运行结果:

4、Manage()的使用

        如果使用 Pool 创建进程,就需要使用 multiprocessing.Manager()中的 Queue()来完成进程间的通信,而不是 multiprocessing.Queue(),否则会抛出异常。

示例代码:

import time
from multiprocessing import Manager, Pool, Queue


def write_data(q):
    # 将列表元素写入到队列中
    for i in ['aa', 'bb', 'cc', 'dd']:
        print('开始写入值%s' %i)
        q.put(i)
        time.sleep(1)


def read_data(q):
    print("开始读取数据...")
    while True:
        if not q.empty():
            print("读取到数据:", q.get())
            time.sleep(1)
        else:
            break


if __name__ == '__main__':
    # 创建队列
    q = Manager().Queue()
    # q = Queue()  # 直接这样使用Queue()会报错
    # 创建进程池
    p = Pool(3)
    # 使用apply阻塞模式创建进程
    p.apply(write_data, (q, ))
    p.apply(read_data, (q, ))
    p.close()
    p.join()

运行结果:

示例代码:

import os
from multiprocessing import Manager, Process


# 定义了一个foo函数,接收一个字典和一个列表
def foo(dic, lst):
    # 字典和列表都放进程ID
    dic[os.getpid()] = os.getpid()
    lst.append(os.getpid())


if __name__ == '__main__':

    # 生成Manager对象
    manager = Manager()
    dic = manager.dict()
    print(dic)
    lst = manager.list(range(3))
    print(lst)

    # 10个进程分别join
    p_list = []
    for i in range(10):
        p = Process(target=foo, args=(dic, lst))
        p.start()
        p_list.append(p)

    for res in p_list:
        res.join()

    # 打印字典和列表
    print(dic)
    print(lst)

运行结果:

示例代码:

from multiprocessing import Pool, current_process, Manager
import time


def produce_data(queue):
    for i in range(10):
        queue.put(i)


def consume_data(queue):
    while queue.qsize() > 0:
        data = queue.get()  # 注意:当get()拿不到数据时,会一直处于等待状态
        print(f"当前进程为:{current_process().name}, 队列获取数据为:{data},队列剩余数据为:{queue.qsize()}个!")
        time.sleep(0.01)


if __name__ == '__main__':
    print(f"主进程{current_process().name}开始执行!")
    p = Pool(processes=6, maxtasksperchild=6)
    queue = Manager().Queue(maxsize=20)

    p.apply_async(produce_data, args=(queue, ))
    time.sleep(1)
    for i in range(5):
        p.apply_async(consume_data, args=(queue, ))

    p.close()  # 关闭进程池,防止将任何其他任务提交到池中。需要在join之前调用,否则会报ValueError: Pool is still running错误
    p.join()  # 等待进程池中的所有进程执行完毕
    print(f"主进程{current_process().name}结束!")

运行结果:

注意:

  • p.close()  # 关闭进程池,防止将任何其他任务提交到池中。需要在join之前调用,否则会报ValueError: Pool is still running错误
  • p.join()  # 等待进程池中的所有进程执行完毕
  • p.close()是关掉进程池子,是不再向里面添加进程了,对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了。

5、current_process()的使用

示例代码:

from multiprocessing import Process, current_process
import time
import random

lst = []


def task(i):
    print(current_process().name, i, 'start...')  # current_process().name输出进程的名字
    time.sleep(random.randint(1, 4))
    lst.append(i)
    print(lst)
    print(current_process().name, i, 'end.....')


if __name__ == "__main__":
    p_lst = []
    for i in range(4):
        p = Process(target=task, args=(i, ))
        p_lst.append(p)
        p.start()
    for p in p_lst:
        p.join()    # 阻塞当前进程,直到子进程全部退出
    print("main end.......")

运行结果:

6、进程池

        进程池里有固定数量的进程,每次执行任务时都从进程池中取出一个空闲进程来执行,如果任务数量超过进程池中进程数量,那么就等待已经在执行的任务结束之后,有进程空闲之后再执行,也就是说,同一时间,只有固定数量的进程在执行,这样对操作系统得压力也不会太大,效率也得到保证。

示例代码:

from multiprocessing import Pool, current_process
import time
import random

lst = []


def task(i):
    print(current_process().name, i, 'start...')
    time.sleep(random.randint(1, 5))
    lst.append(i)
    print(lst)
    print(current_process().name, i, 'end.....')


if __name__ == "__main__":
    p = Pool(processes=3, maxtasksperchild=3)
    for i in range(10):
        p.apply_async(func=task, args=(i,))  # 进程池接收任务
    p.close()  # 关闭进程池 ==》 不接受任务
    p.join()  # 等待子进程执行完毕,父进程再执行
    print("end.............")

运行结果:

示例代码:   【同步执行】

import os
import time
import random
from multiprocessing import Pool


def func1(n):
    print('任务{}开始执行,进程为:{}'.format(n, os.getpid()))

    time.sleep(random.randint(1, 4))

    print('任务{}结束执行,进程为:{}'.format(n, os.getpid()))


if __name__ == '__main__':
    # c创建一个进程池,里面有三个进程
    p = Pool(3)

    for i in range(10):
        res = p.apply(func1, args=(i,))

运行结果:

示例代码:   【异步执行】

import os
import time
import random
from multiprocessing import Pool


def func1(n):
    print('任务{}开始执行,进程为:{}'.format(n, os.getpid()))

    time.sleep(random.randint(1, 4))

    print('任务{}结束执行,进程为:{}'.format(n, os.getpid()))


if __name__ == '__main__':
    # c创建一个进程池,里面有三个进程
    p = Pool(3)

    for i in range(5):
        res = p.apply_async(func1, args=(i,))

    p.close()  # 一定要关闭

    p.join()  # 一定要使用join,不然进程池里的进程没来得及执行,主进程结束了,子进程也都跟着结束。

运行结果:

7、进程共享变量

        共享变量不适用于多进程,进程间的变量是互相隔离的,子进程的全局变量是完全复制一份父进程的数据,对子进程的全局变量修改完全影响不到其他进程的全局变量。

示例代码:

import time
from multiprocessing import Process


def producer(a):
    a += 1
    time.sleep(2)


def consumer(a):
    time.sleep(3)
    data = a
    print(data)


if __name__ == "__main__":
    a = 1
    my_producer = Process(target=producer, args=(a, ))
    my_consumer = Process(target=consumer, args=(a, ))
    my_producer.start()
    my_consumer.start()
    my_producer.join()
    my_consumer.join()

# 输出结果为1

运行结果:

示例代码:   【进程之间的变量是无法共享的,即使是全局变量也是不能共享的】

from multiprocessing import Process
import os


def func():
    global n
    n = 10
    print('子进程pid:{},n:{}'.format(os.getppid(), n))


if __name__ == '__main__':
    n = 100
    print('主进程pid:{},n:{}'.format(os.getppid(), n))
    p = Process(target=func)
    p.start()
    p.join()
    print('主进程中输出n:{}'.format(n))

运行结果:

8、管道Pipe(两进程间的通信优先考虑)

        Pipe([duplex]):在进程之间创建一条管道,并返回元组(conn1,conn2),其中conn1,conn2表示管道两端的连接对象,强调一点:必须在产生Process对象之前产生管道。dumplex:默认管道是全双工的,如果将duplex射成False,conn1只能用于接收,conn2只能用于发送。

  • conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收,recv方法会一直阻塞。如果连接的另外一端已经关闭,那么recv方法会抛出EOFError。
  • conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象
  • conn1.close():关闭连接。如果conn1被垃圾回收,将自动调用此方法
  • conn1.fileno():返回连接使用的整数文件描述符
  • conn1.poll([timeout]):如果连接上的数据可用,返回True。timeout指定等待的最长时限。如果省略此参数,方法将立即返回结果。如果将timeout射成None,操作将无限期地等待数据到达。
  • conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息,超过了这个最大值,将引发IOError异常,并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭,再也不存在任何数据,将引发EOFError异常。
  • conn.send_bytes(buffer [, offset [, size]]):通过连接发送字节数据缓冲区,buffer是支持缓冲区接口的任意对象,offset是缓冲区中的字节偏移量,而size是要发送字节数。结果数据以单条消息的形式发出,然后调用c.recv_bytes()函数进行接收    
  • conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息,并把它保存在buffer对象中,该对象支持可写入的缓冲区接口(即bytearray对象或类似的对象)。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间,将引发BufferTooShort异常。

示例代码:

import time
from multiprocessing import Process, Queue, Pool, Manager, Pipe


def producer(pipe):
    pipe.send("a")
    time.sleep(3)
    print(pipe.recv())


def consumer(pipe):
    time.sleep(2)
    data = pipe.recv()
    pipe.send("b")
    print(data)


if __name__ == "__main__":
    # Pipe实现两进程间通信
    s_pipe, r_pipe = Pipe()
    pool = Pool()
    pool.apply_async(producer, args=(s_pipe, ))
    pool.apply_async(consumer, args=(r_pipe, ))
    pool.close()
    pool.join()

运行结果:

示例代码:

from multiprocessing import Process, Pipe


def f(conn):
    conn.send('主进程,你好呀!')  # 发送数据给主进程
    print('子进程收到主进程发来的数据:{}'.format(conn.recv()))
    conn.close()  # 关闭


if __name__ == '__main__':
    # Pipe是一个函数,返回的是一个元组
    parent_conn, child_conn = Pipe()
    # 创建一个子进程
    p = Process(target=f, args=(child_conn,))
    p.start()
    print("主进程收到子进程发来的数据:{}".format(parent_conn.recv()))
    parent_conn.send('子进程,你好啊!')  # 发送数据给子进程

    p.join()

运行结果:

9、进程之间的同步控制

9.1 进程锁:Lock()

        当多个进程对同一资源进行IO操作时,需要对资源“上锁”,否则会出现意外结果。上锁之后,同一件就只能有一个进程运行上锁的代码块。例如有一个txt文件,里面内容是一个数字10,我们要用多进程去读取这个文件的值,然后每读一次,让txt中的这个数字减1,不加锁时代码如下:

import time
import os
from multiprocessing import Process
from multiprocessing import Lock


def func():
    if os.path.exists('num.txt'):
        with open('num.txt', 'r') as rf:
            num = int(rf.read())
            num -= 1
        time.sleep(1)
        with open('num.txt', 'w') as wf:
            wf.write(str(num))
    else:
        with open('num.txt', 'w') as wf:
            wf.write('10')


if __name__ == '__main__':

    print("主进程开始运行……")
    p_list = []
    for i in range(10):
        p = Process(target=func)
        p_list.append(p)
        p.start()

    for p in p_list:
        p.join()

    with open('num.txt', 'r') as f:
        num = int(f.read())

    print('最后结果为:{}'.format(num))
    print("主进程结束运行……" )

运行结果:

        虽然用了10个进程读取并修改txt文件,但最后的值却不是1。这正是多进程共同访问资源造成混乱造成的。要达到预期结果,就要给资源上锁:

import time
import os
from multiprocessing import Process
from multiprocessing import Lock


def func(lock):
    if os.path.exists('num.txt'):
        lock.acquire()
        with open('num.txt', 'r') as f:
            num = int(f.read())
            num -= 1
        time.sleep(1)

        with open('num.txt', 'w') as f:
            f.write(str(num))
        lock.release()
    else:
        with open('num.txt', 'w') as f:
            f.write('10')


if __name__ == '__main__':

    print("主进程开始运行……")
    lock = Lock()
    p_list = []
    for i in range(10):
        p = Process(target=func, args=(lock,))
        p_list.append(p)
        p.start()

    for p in p_list:
        p.join()

    with open('num.txt', 'r') as f:
        num = int(f.read())

    print('最后结果为:{}'.format(num))
    print("主进程结束运行……")

运行结果:

        果然,用了进程锁之后获得了预料中的结果。但是,如果你运行了上面两块代码你就会发现,加了锁之后,程序明显变慢了很多,因为程序成了串行的了,当然好处是数据安全有保证。

9.2 信号量:Semaphore

        锁同时只允许一个线程更改数据,而信号量是同时允许一定数量的进程更改数据 。假如有一下应用场景:有10个人吃饭,但只有一张餐桌,只允许做3个人,没上桌的人不允许吃饭,已上桌吃完饭离座之后,下面的人才能抢占桌子继续吃饭,如果不用信号量,肯定是10人一窝蜂一起吃饭:

from multiprocessing import Process
import time
import random


def fun(i):
    print('{}号顾客上座,开始吃饭'.format(i))
    time.sleep(random.randint(3, 8))
    print('{}号顾客吃完饭了,离座'.format(i))


if __name__ == '__main__':

    for i in range(10):
        p = Process(target=fun, args=(i,))
        p.start()

运行结果:

用了信号量,实现了轮流吃饭,每次只有3个人吃饭:

示例代码:

from multiprocessing import Process
import time
import random
from multiprocessing import Semaphore


def fun(i , sem):
    sem.acquire()
    print('{}号顾客上座,开始吃饭'.format(i))
    time.sleep(random.randint(3, 8))
    print('{}号顾客吃完饭了,离座'.format(i))
    sem.release()


if __name__ == '__main__':

    sem = Semaphore(3)
    for i in range(10):
        p = Process(target=fun, args=(i,sem))
        p.start()

运行结果:

        事实上,Semaphore的作用也类似于锁,只不过在锁机制上添加了一个计数器,允许多个人拥有“钥匙”。

9.3 事件:Event

python进程的事件用于主进程控制其他子进程的执行,Event类有如下几个主要方法:

  1)wait()    插入在进程中插入一个标记(flag)默认为 False,当 flag为False时,程序会停止运行进入阻塞状态;

  2)set()     使flag为True,程序会进入非阻塞状态

  3)clear()      使flag为False,程序会停止运行,进入阻塞状态 

  4)is_set()   判断flag  是否为True,是的话返回True,不是则返回False

  有如下需求:获取当前时间的秒数的个位数,如果小于5,则设置子进程阻塞,如果大于5则设置子进程非阻塞。代码如下:

from multiprocessing import Event, Process
import time
from datetime import datetime


def func(e):
    print('子进程:开始运行……')
    while True:
        print('子进程:现在事件秒数是{}'.format(datetime.now().second))
        e.wait()  # 阻塞等待信号  这里插入了一个flag  默认为 False
        time.sleep(1)


if __name__ == '__main__':

    e = Event()
    p = Process(target=func, args=(e,))
    p.start()
    for i in range(10):
        s = int(str(datetime.now().second)[-1])  # 获取当前秒数的个位数
        if s < 5:
            print('子进程进入阻塞状态')
            e.clear()  # 使插入的flag为False 进程进入阻塞状态
        else:
            print('子进程取消阻塞状态')
            e.set()  # 使插入的flag为True,进程进入非阻塞状态
        time.sleep(1)
    e.set()
    time.sleep(3)
    p.terminate()
    print("主进程运行结束……")

运行结果:

10、内置线程池

示例代码:

import time
import os
import random
from multiprocessing.pool import ThreadPool


def task():
    print(f'开始执行任务:{os.getpid()}')
    time.sleep(random.randint(0, 5))
    print(f"执行任务结束:{os.getpid()}")


if __name__ == '__main__':
    pool = ThreadPool(2)
    for i in range(5):
        pool.apply_async(task)
    pool.close()
    pool.join()

运行结果:

参考博文:

Python并发编程系列之多进程(multiprocessing) - 走看看

线程池的极简用法——内置线程池multiprocessing - 皓敐 - 博客园

python多进程总结 - fengf233 - 博客园

  • 5
    点赞
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python,multiprocessing模块提供了一种用于创建和管理多个进程的方法,以实现并行计算的目的。其,multi函数是multiprocessing模块的一个重要函数之一,用于创建多个进程并并发地执行任务。 multi函数的使用方法如下: 首先,在代码导入multiprocessing模块:import multiprocessing 接下来,定义一个函数来作为子进程的任务,该函数会在多个进程并发执行。例如,我们可以定义一个计算平方的函数: def square(x): return x * x 然后,使用multi函数来创建多个进程并执行任务: if __name__ == '__main__': # 创建一个进程池,指定最大进程数为4 pool = multiprocessing.Pool(processes=4) # 使用进程池的map函数并发地执行square函数,传入参数为[1, 2, 3, 4, 5] result = pool.map(square, [1, 2, 3, 4, 5]) # 输出结果 print(result) 在上述代码,首先创建了一个进程池,通过multiprocessing.Pool(processes=4)指定了最大进程数为4。然后,使用进程池的map函数并发地执行任务函数square,并传入参数为[1, 2, 3, 4, 5]。最后,通过print函数输出执行结果。 运行以上代码,将会得到[1, 4, 9, 16, 25]这样一个输出结果,即计算每个数字的平方。 总结来说,Pythonmulti函数通过创建多个进程来实现并发执行任务。使用multi函数需要导入multiprocessing模块,并配合进程池的map函数来并发地执行任务函数。以上是multi函数的使用方法,在实际应用可以根据需要进行进一步的优化和扩展。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值