python进程

python开启进程

import os
import time

ret = os.fork()

if ret > 0:
    while True:
        print("-----父进程------pid=%s" % os.getpid())
        time.sleep(1)
else:
    while True:
        print("-----子进程------pid=%s-ppid=%s" % (os.getpid(), os.getppid()))
        time.sleep(1)

父进程和子进程都会从fork()函数中得到一个返回值，在子进程中这个值一定是0，而父进程中是子进程的 id号

• 注：
  进程可以实现多任务，但是代价较大，开销较高
  多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响

下面是fork炸弹，不信的话可以执行下试试

import os
while True:
        os.fork()

python多进程跨平台

multiprocessing模块就是跨平台版本的多进程模块。

from multiprocessing import Process
import time


def test():
   while True:
       print("-------test-----")
       time.sleep(1)


p = Process(target=test)
p.start()
# p.join() 等待子进程执行完毕 主进程才会执行 =====》堵塞

# p.terminate()  # 终止进程

#
# while True:   #主进程等待支进程执行完毕才会结束 不同于fork()
#     print("----main----")
#     time.sleep(1)

进程池Pool

from multiprocessing import Pool
import time
import os


def worker(num):
    for i in range(5):
        print("=====%d==%d==" % (os.getpid(), num))
        time.sleep(1)


# 3表示进程池中最多有3个进程一块执行
pool = Pool(3)

for i in range(10):
    print("-----%d-----" % i)
    # 向进程池中添加任务
    pool.apply_async(worker, (i,))

    # pool.apply(worker, (i,)) # 堵塞方式运行
# 关闭进程池 相当于不能再添加新任务了
pool.close()
# 主进程 创建 添加 任务后 主进程默认不会等待进程池中的任务执行完才会结束 
# 添加这句话的意思是告诉主进程 等待进程池中的任务执行完毕 再结束主进程
pool.join()

进程间通信

from multiprocessing import Process, Queue
import os, time, random


# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())


# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break


if __name__ == '__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 等待pw结束:
    pw.join()
    # 启动子进程pr，读取:
    pr.start()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print('')
    print('所有数据都写入并且读完')

from multiprocessing import Manager,Pool
import os,time,random

def reader(q):
    print("reader启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s"%q.get(True))

def writer(q):
    print("writer启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
    for i in "dongGe":
        q.put(i)

if __name__=="__main__":
    print("(%s) start"%os.getpid())
    q=Manager().Queue() #使用Manager中的Queue来初始化
    po=Pool()
    #使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取
    po.apply(writer,(q,))
    po.apply(reader,(q,))
    po.close()
    po.join()
    print("(%s) End"%os.getpid())