python 3.041 多进程

> 这里介绍 multiprocessing

#例子
**通过Value 和Array来共享内存**
其中数据类型使用的是ctypes
https://docs.python.org/2.7/library/ctypes.html#module-ctypes
```
#!/usr/bin/python
import  multiprocessing,time,ctypes

def the_proc(num,arr):
    the_proc_object = multiprocessing.current_process() #获得当前进程对象
    my_name = the_proc_object.name  #获得进程名字
    while True:
        if lock.acquire():   #获得锁，阻塞，直到获得锁为止
            num.value = num.value + 1  #共享变量
            arr[int(my_name)]=my_name  #共享数组
            lock.release()             #释放锁
            break
        else:
            time.sleep(1)
    #time.sleep(1)

if __name__ == '__main__':
    num = multiprocessing.Value(ctypes.c_int,0)  #共享变量，int
    #arr = multiprocessing.Array(ctypes.c_char_p,["a","b"])  #共享数组，字符串
    arr = multiprocessing.Array(ctypes.c_char_p,10)   #共享数组，字符串，限10个
    lock = multiprocessing.Lock()   #锁
    #lock = multiprocessing.RLock()  #可以被同一个进程重复获得的锁

for i in range(10):
        p = multiprocessing.Process(target=the_proc, args=(num, arr),name=str(i))
        #触发进程
        p.start()  #开始
        #p.join()  #等待进程跑完
        print "pid==>"+str(p.pid)  #进程id
        print "is_live==>"+str(p.is_alive())  #进程是否活着
        #p.terminate()  #发SIGTERM信号 
        #time.sleep(1)
        #print "exit_code==>"+str(p.exitcode)  #获得返回值，没有跑完返回None

print "cpu number ===>" + str(multiprocessing.cpu_count())  #获得cpu 数量
    print "sub process list:"
    print multiprocessing.active_children()    #获得当前进程
    time.sleep(3)
    print multiprocessing.active_children()
    print num.value
    print arr[:]
```
***
#通过Pool 限制进程数量
```
#!/usr/bin/python
import  multiprocessing,time,ctypes

def the_proc(num):
    print num
    time.sleep(2)

if __name__ == '__main__':

pool = multiprocessing.Pool(5)   #限制同时最多跑5个进程
    for i in range(10):
        pool.apply_async(the_proc,(i,)) #触发进程

pool.close()   #不再接受新的进程
    #time.sleep(1)
    #pool.terminate()  #立刻结束所有进程
    pool.join()    #等待所有进程结束
```
***
#Pipe 和 Queues
**Pipe:**双向的管道
```
#!/usr/bin/python
import  multiprocessing,time,ctypes

def the_proc_1(the_pipe):
    the_pipe.send(0)     #向管道发送消息
    while True:
        num = the_pipe.recv()  #从管道获得消息
        print "1==>"+str(num)
        if num == 9 :
            the_pipe.send(num)
            break
        else :
            the_pipe.send(num+1)

def the_proc_2(the_pipe):
    while True:
        num = the_pipe.recv()
        print "2==>"+str(num)
        if num == 9 :
            the_pipe.send(num)
            break
        else :
            the_pipe.send(num+1)

if __name__ == '__main__':
    pipe = multiprocessing.Pipe()  #创建管道

p1 = multiprocessing.Process(target=the_proc_1, args=(pipe[0],)) #给予管道的一端
    p2 = multiprocessing.Process(target=the_proc_2, args=(pipe[1],)) #给予管道的另一端
    p1.start()
    p2.start()
    p1.join()
    p2.join()
```
**Queue**与Pipe 相比，允许多个进程同时连接
```
#!/usr/bin/python
import  multiprocessing,time,ctypes

def input_queue(queue):  #插队列的
    for i in range(12):
        queue.put(i)    #插入信息

def output_queue(queue):  #读队列的
    while True:
        pid = multiprocessing.current_process().pid
        num = queue.get(True,10)  #读取信息， Ture 代表阻塞，10 代表等10秒
        print str(pid)+"==>"+str(num)
        time.sleep(1)
        if  queue.empty():
            break

if __name__ == '__main__':
    queue = multiprocessing.Queue(100) #队列最多100个
    print queue.qsize()   #队列长度
    print queue.empty()   #队列是否为空
    print queue.full()    #队列是否为满
    p1 = multiprocessing.Process(target=input_queue, args=(queue,))
    p2 = multiprocessing.Process(target=output_queue, args=(queue,))
    p3 = multiprocessing.Process(target=output_queue, args=(queue,))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
```

乱读天书， 不求甚解

乱读天书，不求甚解