Python多进程

Python中提供了函数和类来实现多进程

创建多进程

使用函数方式

import multiprocessing
import time

def worker(sec):
    time.sleep(sec)
    print('这是进程的名字', multiprocessing.current_process().name)
    time.sleep(sec)

if __name__ == '__main__':

    print('这是主进程:', multiprocessing.current_process().name)
    
    s_time = time.time()
    p1 = multiprocessing.Process(target=worker, args=(2,))
    p2 = multiprocessing.Process(target=worker, args=(2,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print('主进程结束', multiprocessing.current_process().name)
    print('一共用时', time.time()-s_time)

使用类方式

import multiprocessing
import time

class Worker(multiprocessing.Process):

    def __init__(self, sec):
        super(Worker, self).__init__()
        self.sec = sec

    def run(self):
        time.sleep(self.sec)
        print('这是进程的名字', multiprocessing.current_process().name)
        time.sleep(self.sec)


if __name__ == '__main__':
    print('主进程开始:', multiprocessing.current_process().name)
    s_time = time.time()

    pro_list = []
    for i in range(4):
        worker = Worker(2)
        pro_list.append(worker)

    for p in pro_list:
        p.start()

    for p in pro_list:
        p.join()

    print('主进程结束', multiprocessing.current_process().name)
    print('一共用时', time.time()-s_time)

使用以上两种方式创建多进程时,join()方法与多线程效果相同,多线程设置守护线程的命令是
t.setDaemon(True), 而多进程设置守护进程的命令是p.daemon = True

进程锁Lock()

进程锁可以避免因为多个进程访问共享资源而发生冲突。

  • 不使用进程锁
import multiprocessing
import sys

def worker(f):
    f = open(f, 'w')
    n = 100000
    while n > 1:
        f.write("The number is %s \n" %n)
        n -= 1
    f.close()


if __name__ == "__main__":
    f = "file.txt"
    p1 = multiprocessing.Process(target=worker, args=(f,))
    p2 = multiprocessing.Process(target=worker, args=(f,))

    p1.start()
    p2.start()

可以看到,文件在写入的时候并没有按照我们想要的顺序。

  • 使用进程锁
import multiprocessing
import sys

def worker(lock, f):

    lock.acquire()
    fs = open(f, 'a+')
    n = 100
    while n > 1:
        fs.write("The number is \n")
        n -= 1
    fs.close()
    lock.release()

if __name__ == "__main__":

    lock = multiprocessing.Lock()
    f = "file.txt"
    p1 = multiprocessing.Process(target=worker, args=(lock, f))
    p2 = multiprocessing.Process(target=worker, args=(lock, f))
    p1.start()
    p2.start()

Semaphore

Semaphore控制访问共享资源的数量

import multiprocessing
import time

def worker(s, i):
    s.acquire()
    print("进程%s acquire" %multiprocessing.current_process().name);
    time.sleep(i)
    print('进程%s 正在访问资源' %multiprocessing.current_process().name)
    print("进程%s release" %multiprocessing.current_process().name);
    s.release()

if __name__ == "__main__":
    s = multiprocessing.Semaphore(2)

    pro_list = []
    for i in range(5):
        p = multiprocessing.Process(target = worker, args=(s, i))
        pro_list.append(p)

    for p in pro_list:
        p.start()

由于我们设置了访问某个资源的最大进程数是2,所以最多只能有两个进程可以同时访问该资源,当某一个进程释放之后,其他的进程才可以访问,以此来保证不超过最大访问数。

进程池Pool

import multiprocessing
from multiprocessing import Process,Pool
import time

def run(sec):
    time.sleep(sec)
    print('进程%s正在执行!' % multiprocessing.current_process().name)
    time.sleep(sec)

if __name__ == '__main__':
    print('主进程开始了 ' ,multiprocessing.current_process().name)
    s_time = time.time()
    p = Pool(5)      # 最大并发进程数
    for i in range(10):
        p.apply_async(run, args=(2,))

    p.close()    # 关闭进程池
    p.join()

    print('主进程结束', multiprocessing.current_process().name)
    print('一共用时: ', time.time()-s_time)

posted @   cnkai  阅读(808)  评论(0编辑  收藏  举报
编辑推荐:
· 深入理解 Mybatis 分库分表执行原理
· 如何打造一个高并发系统?
· .NET Core GC压缩(compact_phase)底层原理浅谈
· 现代计算机视觉入门之:什么是图片特征编码
· .NET 9 new features-C#13新的锁类型和语义
阅读排行:
· Sdcb Chats 技术博客:数据库 ID 选型的曲折之路 - 从 Guid 到自增 ID,再到
· 语音处理 开源项目 EchoSharp
· 《HelloGitHub》第 106 期
· Spring AI + Ollama 实现 deepseek-r1 的API服务和调用
· 使用 Dify + LLM 构建精确任务处理应用
点击右上角即可分享
微信分享提示