python之多进程

实例一：
一个简单的多进程实例，要创建进程，需要motiproceing模块。用法和创建线程的差不多。这个程序，实现了创建5个进程，然后每个进程再创建了一个线程。

import multiprocessing
import time
import threading
def f(name):
    time.sleep(2)
    print("hello",name)
    t=threading.Thread(target=thread_run,)
    t.start()

def thread_run():
    print(threading.get_ident())

if __name__ == '__main__':
    for i in range(5):
        p=multiprocessing.Process(target=f,args=('bob %s'%i,))
        p.start()



F:\anaconda\python.exe F:/web/s14/进程、线程/noke.py
hello bob 3
hello bob 0
3820
1992
hello bob 1
3516
hello bob 2
1256
hello bob 4
3744

实例二：
类似于上面的程序，只不过实现了打印当前进程的父进程号和当前进程号，然后在当前进程下创建了子进程，然后打印子进程的父进程号，再打印该子进程号，会得出：每一个子进程都是由父进程启动的

from multiprocessing import Process
import os
def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())
    print("\n\n")


def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)


if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()


F:\anaconda\python.exe F:/web/s14/进程、线程/noke.py
main process line
module name: __main__
parent process: 1268
process id: 2108



function f
module name: __mp_main__
parent process: 2108
process id: 4040



hello bob

实例三：进程间数据共享的第一种方法：队列
下面这个程序，通过队列，实现了线程间数据共享，注意：这个队列只是普通的队列，没有进行任何封装
queue，线程间的queue是实现线程间生产者消费者模型的，但是只能在当前程序的线程里访问

import queue
import threading


def f(q):
    q.put([42, None, 'hello'])


if __name__ == '__main__':
    q = queue.Queue()
    p = threading.Thread(target=f, args=(q,))
    p.start()
    print(q.get())
    p.join()

下面这个程序，并没有使用正常的queue。使用了封装后的queue
原理：相当于克隆了一个queue。因为在父进程创建子进程的时候放进去queue， 通过一个中间内存，pickle一下序列化一下，再反序列化一下。只是实现了数据的传递

from multiprocessing import Process, Queue
import queue  #不能是线程queue

def f(q):
    q.put([42, None, 'hello'])


if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))        #虽然进程间内存不共享，但是我们可以在进程出生时，其他进程给新进程传数据
    p.start()
    print(q.get())  # prints "[42, None, 'hello']"
    p.join()

实例四：进程间数据共享的第二种方法：管道

from multiprocessing import Process, Pipe


def f(conn):
    conn.send([42, None, 'hello'])
    conn.send([42, None, 'hello2'])
    conn.send([42, None, 'hello3'])
    conn.close()


if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())
    print(parent_conn.recv())
    print(parent_conn.recv())
    p.join()


F:\anaconda\python.exe F:/web/s14/进程、线程/noke.py
[42, None, 'hello']
[42, None, 'hello2']
[42, None, 'hello3']

实例五：
刚才只是两个进程间数据的传递
那么，如何向在多线程一样同时修改数据呢？
使用manager，注意：不需要加锁，manager默认加锁了，共享数据的原理和queue原理一样

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[os.getpid()]=os.getpid()
    l.append(os.getpid())
    print(l)


if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()      #生成一个字典可在多个进程间共享和传递

        l = manager.list(range(5))  #一样
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()

        print(d)
        print(l)

实例六：进程同步：加锁的目的，控制打印顺序（对屏幕进行加锁）
进程里面为什么需要锁？
虽然每个进程都是独立的，但是对于屏幕来说，屏幕不是共享的，控制打印顺序
在windows里面试不出来，在linux里面可以试出来
存在的意义：就是在屏幕上打印

from multiprocessing import Process, Lock


def f(l, i):
    l.acquire()
    print('hello world', i)
    l.release()
if __name__ == '__main__':
    lock = Lock()
    for num in range(10):
        Process(target=f, args=(lock, num)).start()


F:\anaconda\python.exe F:/web/s14/进程、线程/noke.py
hello world 3
hello world 6
hello world 7
hello world 8
hello world 2
hello world 9
hello world 0
hello world 1
hello world 4
hello world 5

实例七：进程池的使用（生产中常用的）
我们启动多进程明显很慢，因为开销特别大，所以我们使用线程池。注意:启动特别多的线程仅仅是cpu上下文切换变多，一般情况，系统只是变慢，而启动特别多的进程，容易把系统搞瘫痪

from multiprocessing import Process, Pool,freeze_support
import time
import os

def Foo(i):
    time.sleep(2)
    print("in process ",os.getpid())
    return i + 100

def Bar(arg):
    print('-->exec done:', arg,os.getpid())


if __name__ == '__main__':      #为了区分是主动执行这个脚本，还是导入的模块  意思就是这样写，手动执行这个脚本，就会执行，而导入不会执行
    print("主进程 pid",os.getpid())
    pool = Pool(3)              #允许进程池里同时放入5个进程，放入进程池里的进程才会运行，其他进程挂起
    for i in range(10):
        pool.apply_async(func=Foo, args=(i,), callback=Bar) #并行 ，callback回调 干完foo才能干bar，干不完foo不干bar。  主进程调用的回调。备份完毕自动向数据库写日志。为什么不在子进程写日志？因为父进程只连一次，而子进程要连10次。
        #pool.apply(func=Foo, args=(i,))     #串行

    print('end')
    pool.close()    #一定要先关闭进程池再join
    pool.join()  # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭，不等进程执行完毕程序直接关闭 先close在join