python 多进程编程，进程的通信，进程池的运用，进程的退出

python 多进程

主要使用的库：multiprocessing

测试代码：    (为了节省空间，一些空行删了，为了规范，在特定场合不要删除)

基本使用

import os
import time
from multiprocessing import Process

def task(n):
    while n:
        n -= 1
        print "task: pid %s %d" % (str(os.getpid()), n)
        time.sleep(1)

def main():
    p1 = Process(target=task, args=(5,))
    p2 = Process(target=task, args=(5,))

    p1.start()
    p2.start()
    p1.join()  # 加入到当前主线程，使得主线程等待当前线程执行完成，才往下执行
    p2.join()

    print "End"

if __name__ == '__main__':
    main()

多进程通信

使用：mulitprocessing中的Queue
例子：使用了生产者消费者模式进行通信，在一些情况下需要注意数据的同步问题，也是编程方面需要注意的，暂不考虑

# coding=utf8
__author__ = 'Administrator'

import os
import sys
import time
import signal
import random
from multiprocessing import Process
from multiprocessing import Queue

def produce(message_queue):
    while True:
        if message_queue.qsize() < 5:
            tmp = random.randint(0, 0xfff)
            message_queue.put(tmp)
            print "produce: %s " % str(tmp)
        time.sleep(1)


def consume(message_queue):
    while True:
        if not message_queue.empty():
            print "consume: %s " % str(message_queue.get())
        time.sleep(1)

def produce_consume():
    message_queue = Queue(maxsize=100)  # 使用进程提供的Queue 类，保证数据可以在进程之间共享
    for item in range(0, 10):  # 队列初始化
        message_queue.put(random.randint(0, 0xfff))

    producer = Process(target=produce, args=(message_queue,))  # 启动生产者进程
    consumer = Process(target=consume, args=(message_queue,))  # 启动消费者进程

    producer.start()  # 启动进程
    consumer.start()
    producer.join()  # 加入到主进程之中
    consumer.join()

    print "end"


if __name__ == '__main__':
    produce_consume()

很多个进程的使用

使用：进程池，multiprocessing中的Pool

import os
import sys
import time
import signal
import random
from multiprocessing import Process
from multiprocessing import Queue
from multiprocessing import Pool

def pool_task(message_list):
    while len(message_list):
        print "task: %s, %s" % (str(os.getpid()), str(message_list.pop()))
        time.sleep(1)

def process_pool():
    p = Pool()
    x = ["a", "b", "c"]
    for i in xrange(0, 3):
        tmp = [str(x_i) + str(item) for x_i, item in enumerate(x)]
        p.apply_async(pool_task, args=(tmp,))  # 异步执行，使用apply()的时候，其内部同样是调用了apply_async
    p.close()
    p.join()

if __name__ == '__main__':
    process_pool()

进程的退出

通常有几种方式，结束进程：

1. sys.exit(0) ，退出当前进程，里面的0是退出码
2. os._exit() ,受操作系统限制，但在win32和unix平台不受影响
3. os.kill(pid, singnal)， 结束掉一个进程，需要提供进程ID
4. os.popen(“taskkill.exe /pid:”+ str(pid)) 结束掉window 平台的进程

一般常用的是 sys.exit(0) 和 os.kill