Python之多进程

 

简单理解进程与线程
　　进程：
　　　　1.进程是系统资源分配的最小单位
　　　　2.进程是一堆系统资源的集合，不可执行
　　　　3.进程内可以有多个线程
　　　　4.进程间内存等所有的资源空间互相隔离，要实现资源数据通信可通过建立socket规则

　　线程：
　　　　1.线程是程序执行的最小调度单位
　　　　2.线程是进程的一个执行流（执行代码）
　　　　3.线程间内存等资源空间数据共享

 

 

 

1. multiprocessing模块的简单使用

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
简单理解进程与线程
    进程：
        进程是系统资源分配的最小单位
        进程是一堆系统资源的集合，不可执行
        进程内可以有多个线程
        进程间内存等所有的资源空间互相隔离，要实现资源数据通信可通过建立socket规则

    线程：
        线程是程序执行的最小调度单位
        线程是进程的一个执行流（执行代码）
        线程间内存等资源空间数据共享
介绍multiprocessing模块多进程的简单使用
'''

import multiprocessing
import threading
import time

# 线程函数
def thread_run():
    # 查看当前线程的id号
    print(threading.current_thread())
    time.sleep(2)

def run(name):
    print("Hello", name)
    # 查看当前的进程信息
    print(multiprocessing.current_process())
    # 注册并运行线程
    t = threading.Thread(target=thread_run())
    t.start()


if __name__ == '__main__':
    for i in range(10):
        # 注册并运行进程
        m = multiprocessing.Process(target=run, args=("boy%s" % i, ))
        m.start()

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
多进程之getid，
.py文件执行，系统调用生成.py文件的主进程，主进程通过multiprocessing模块创建子进程
即：“系统调用程序”为.py文件主进程的父进程，.py文件主进程为子进程的父进程
'''

import multiprocessing
import time
import os

def info(info=None):
    print(info)
    print("Parent Process id:", os.getppid())
    print("Current Process id:", os.getpid())
    print("Process done\n")
    time.sleep(1)

def run():
    # 执行info函数，查看子进程及其父进程的进程id
    info("\033[31;1mFunction Info\033[0m")
    # print("Function done\n")

if __name__ == '__main__':
    # 执行info函数，查看主进程及其父进程的进程id
    info("\033[31;1mProcess Info\033[0m")

    # 注册进程
    t = multiprocessing.Process(target=run, )
    # 运行进程
    t.start()
    # 等待进程执行结束，再往下执行代码
    t.join()

 

2. 进程池，同时执行多少个进程

# -*- coding:utf-8 -*-
# Author:Wong Du

from multiprocessing import Process, Pool
import time

def run(n):
    time.sleep(1)
    print("Hello world", n)
    return n + 1000


def war(arg):
    print("\033[36;1m---exec done---\033[0m", arg)

if __name__ == '__main__':
    pool = Pool(2)
    for i in range(10):
        # pool.apply(run, args=(i, ))   # 同步，即串行
        pool.apply_async(run, args=(i, ), callback=war) # 异步，即并行

    print("end...")
    pool.close()
    pool.join()

 

3. Python中通过Manager方法实现进程间数据共享

# -*- coding:utf-8 -*-
# Author:Wong Du

from multiprocessing import Process, Manager
from os import getpid



# 子进程函数
def run(d, l):
    pid = getpid()
    d[pid] = pid + 1
    l.append(pid)

    print(l)

if __name__ == "__main__":
    # 生成一个manager对象，并创建共享字典d和列表l
    with Manager() as manager:
        d = manager.dict()  # 生成一个空字典，用于数据共享
        l = manager.list(range(5))  # 生成一个空列表，用于数据共享


        p_list = []
        for i in range(10):
            # 注册进程并把共享字典d和共享列表l传进去
            p = Process(target=run, args=(d, l, ))
            p.start()
            p_list.append(p)

        # 确保子进程全部执行完毕再执行下面代码，避免无法访问主进程的共享数据
        for j in p_list:
            j.join()

        print("\033[32;1m%s\033[0m" % d)
        print("\033[33;1m%s\033[0m" % l)

 

4. Python中通过Pipe方法实现进程间交互

# -*- coding:utf-8 -*-
# Author:Wong Du

'''
通过multiprocessing模块的Pipe方法实现进程间的通信
'''

from multiprocessing import Process, Pipe
import time

# 子进程函数
def run(child):
    # 发送数据给parent_conn连接对象
    child.send("Nice to meet you..")
    time.sleep(2)
    # 接收从parent_conn发来的数据
    res = child.recv()
    
    print(res)

if __name__ == "__main__":
    # 建立进程间连接对象
    parent_conn, child_conn = Pipe()
    
    # 注册并将其中一个连接对象传给进程
    p = Process(target=run, args=(child_conn, ))
    # 运行进程
    p.start()
    
    # 接收child_conn发送来的数据
    data = parent_conn.recv()
    # 发送数据给child_conn
    parent_conn.send("Nice to meet you too...")
    
    print(data)

 

5. Python中通过进程Queue实现进程间数据交互

# -*- coding:utf-8 -*-
# Author:Wong Du

"""
import multiprocessing
import queue

def run():
    q.put(["Caiyun",None,"23"])

if __name__ == "__main__":
    q = queue.Queue()
    p = multiprocessing.Process(target=run,)
    p.start()
    print( q.get_nowait() )

# NameError: name 'q' is not defined
"""

"""
import multiprocessing
import queue

def run(q):
    q.put(["Caiyun",None,"23"])

if __name__ == "__main__":
    q = queue.Queue()
    p = multiprocessing.Process(target=run, args=(q, ))
    p.start()
    print( q.get_nowait() )
    
# TypeError: can't pickle _thread.lock objects
"""

"""
import multiprocessing
import threading
import queue

def run():
    q.put(["Caiyun", None, 23])

if __name__ == "__main__":
    q = queue.Queue()
    # p = multiprocessing.Process(target=run, args=(q, ))
    p = threading.Thread(target=run)
    p.start()
    print( q.get_nowait() )

# ['Caiyun', None, 23]
"""

import multiprocessing, time
# from multiprocessing import Queue,Process

# 进程函数
def run(q):
    time.sleep(2)
    # 往进程Queue中加入数据
    q.put(["Caiyun", None, 23])

if __name__ == "__main__":
    # 生成一个进程队列Queue
    q = multiprocessing.Queue()
    
    # 注册进程并发进程Queue传进去
    p = multiprocessing.Process(target=run, args=(q, ))
    # 运行进程
    p.start()

    # 从进程Queue中获取数据
    print(q.get())
    # print( q.get_nowait() )   # 由于两个进程是同时执行的，get_nowait()会出现问题