Python_进程初识

1. 简单理解进程

# Author : Xuefeng

import multiprocessing
import time, threading

def thread_r():
    '''
    定义线程
    :return: 
    '''
    # 打印线程号
    print(threading.get_ident())

def run(name):
    '''
    定义进程操作
    :param name: 名字
    :return: 
    '''
    time.sleep(2)
    print("Hello, ", name)
    # 实例化线程
    t = threading.Thread(target=thread_r)
    t.start()


if __name__ == "__main__":
    for i in range(10):
        # 循环创建进程
        i = multiprocessing.Process(target=run, args=("Jim", ))
        i.start()
        # i.join()

2. 获取进程ID

# Author : Xuefeng

import multiprocessing
import os

def info(n):
    '''
    定义获取进程ID函数
    :param n: 
    :return: 
    '''
    print(n)
    # 打印模块名
    print("Module name:", __name__)
    # 打印父进程ID
    print("Parent ID", os.getppid())
    # 打印本进程ID
    print("Process ID", os.getpid())
    print("\n\n")

def f(name):
    '''
    定义进程函数
    :param name: 名字
    :return: 
    '''
    info("\033[41;1m function \033[0m")
    print("hello", name)

if __name__=="__main__":
    # p = multiprocessing.Process(target=info, args=("Jim", ))
    # p.start()
    info("\033[42;1m  main process \033[0m")
    # 实例化进程
    p1 = multiprocessing.Process(target=f, args=("Jim", ))
    p1.start()

3. 进程队列不同于线程队列

# Author : Xuefeng

from multiprocessing import Process, Queue
import queue
import threading

def f(qq):
    qq.put([22, None, "Jim"])

if __name__=="__main__":
    # 线程队列不能传入子进程
    # q = queue.Queue()

    # 进程队列能够传入子进程进行操作，
    # 通过pickle对传入的数据进行序列化实现父进程与子进程的通信，
    # 相当于在子进程中新建一个相同的队列，没有修改同一份数据
    q = Queue()

    # p = threading.Thread(target=f, )

    # 启动子进程，不能对父进程建立的线程队列进行操作
    p = Process(target=f, args=(q, ))

    p.start()
    print(q.get())

4. 进程池，相当于线程的信号量

# Author : Xuefeng
from multiprocessing import Process,Pool,freeze_support
import os
import time

def Foo(n):
    time.sleep(2)
    print("The function:", os.getpid())
    # 返回值，作为回调函数的参数传入
    return n+10

def Bar(arg):
    print("------exec done", arg)


if __name__=="__main__":
    # 定义进程池大小为5，也就是同时允许5个进程执行
    pool = Pool(5)

    for i in range(10):
        # apply串行执行进程池中的进程
        # pool.apply(func=Foo, args=(i, ))

        # apply_async并行执行进程池中的进程
        # pool.apply_async(func=Foo, args=(i, ))

        # callback回调函数，通过主进程执行，减少父进程与子进程之间的链接步骤，提高效率
        pool.apply_async(func=Foo, args=(i, ), callback=Bar)

    print("-------End---------")
    # 直接关闭进程池，可能会导致进程内容不执行就直接退出
    pool.close()
    # 等待所有进程结束
    pool.join()

5. 进程锁，保证输出结果不混乱

# Author : Xuefeng

from multiprocessing import Process, Lock

def f(L, i):
    L.acquire()
    try:
        print("Hello World ", i)
    finally:
        L.release()

if __name__=="__main__":
    # 创建进程锁，进程锁的作用是保证结果输出不混乱
    lock = Lock()
    for i in range(10):
        Process(target=f, args=(lock, i)).start()