python多进程-----multiprocessing包

            def join(self, timeout=None):
        ‘‘‘
        Wait until child process terminates
        ‘‘‘assert self._parent_pid == os.getpid(), ‘can only join a child process‘assert self._popen isnot None, ‘can only join a started process‘
        res = self._popen.wait(timeout)
        if res isnot None:
            _current_process._children.discard(self)

            #
            !/usr/bin/env python
            __author__ = ‘webber‘import os,time
import multiprocessing

# worker functiondef worker(sign, lock):
    lock.acquire()
    print sign, ‘pid:‘,os.getpid()
    lock.release()
    time.sleep(1)

# Mainprint‘Main:‘,os.getpid()

plist = []
lock = multiprocessing.Lock()
for j in range(5):
    p = multiprocessing.Process(target=worker,args=(‘process‘,lock))
    p.start()
    plist.append(p)
p.join()

#for process in record:
#    process.join()

            def Pipe(duplex=True):
        ‘‘‘
        Returns pair of connection objects at either end of a pipe
        ‘‘‘if duplex:
            s1, s2 = socket.socketpair()
            s1.setblocking(True)
            s2.setblocking(True)
            c1 = _multiprocessing.Connection(os.dup(s1.fileno()))
            c2 = _multiprocessing.Connection(os.dup(s2.fileno()))
            s1.close()
            s2.close()
        else:
            fd1, fd2 = os.pipe()
            c1 = _multiprocessing.Connection(fd1, writable=False)
            c2 = _multiprocessing.Connection(fd2, readable=False)

        return c1, c2

            #
            !/usr/bin/env python
            import
             multiprocessing as mul


            def
             proc1(pipe):

            #
                pipe.send(‘hello‘)
            print
            ‘
            proc1 rec:
            ‘
            ,pipe.recv()


            def
             proc2(pipe):

            #
                print ‘proc2 rec:‘,pipe.recv()
    pipe.send(‘hello too‘)

pipe = mul.Pipe(duplex=False)
#pipe = mul.Pipe()
p1 = mul.Process(target=proc1,args=(pipe[0],))       # 读管道
p2 = mul.Process(target=proc2,args=(pipe[1],))       # 写管道
# 由于管道是单向的，对象pipe[0]只有读的权限(recv)，而pipe[1]只有写的权限(send)。
#print pipep1.start()
p2.start()
p1.join()
p2.join()

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            import
             multiprocessing

            import
             time

            import
             os


            #
             客户进程，向众所周知的FIFO服务器进程发送请求
            def
             client_proc(queue,msg):
    request = ‘I am client ‘ + str(msg) + ‘    pid: ‘+ str(os.getpid()) + ‘   time:‘ + str(time.time())        # 注意信息的格式，都统一为字符串类型    queue.put(request)

def server_proc(queue,lock):
    msg = queue.get()
    lock.acquire()
    print msg + ‘--------------->I am server ‘ + ‘pid: ‘ + str(os.getpid())
    lock.release()

plist_cli = []
plist_ser = []
lock = multiprocessing.Lock()
queue = multiprocessing.Queue()  # 参数为空，默认为队列可无限长for i in range(10):
    p1 = multiprocessing.Process(target=client_proc,args=(queue,i))
    p2 = multiprocessing.Process(target=server_proc,args=(queue,lock))
    p1.start()
    p2.start()
    plist_cli.append(p1)
    plist_ser.append(p2)

for proc in plist_cli:
    proc.join()
    
for proc in plist_ser:
    proc.join()
    
queue.close()

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            import
             multiprocessing

            import
             time


            def
             func(msg):
    
            print
            ‘
            msg:
            ‘
            ,msg
    time.sleep(3)
    print‘end‘

pool = multiprocessing.Pool(processes=3)
for i in xrange(4):
    msg = ‘hello %d‘ % (i)
    pool.apply_async(func,(msg,))     #非阻塞
#    pool.apply(func,(msg,))     #阻塞,apply()源自内建函数，用于间接的调用函数，并且按位置把元祖或字典作为参数传入。#    pool.imap(func,[msg,])      #非阻塞, 注意与apply传的参数的区别
#    pool.map(func,[msg,])        #阻塞print‘Mark~~~~~~~~~~~~~~~‘
pool.close()
pool.join()      # 调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束print‘sub-process done‘

            #
            !/usr/bin/env python
            
#
             -*- coding:utf-8 -*-
            import
             multiprocessing

            import
             time


            def
             func(msg):
    
            print
            ‘
            msg:
            ‘
            ,msg
    time.sleep(3)
    print‘end‘

pool = multiprocessing.Pool(50)
msg = range(50)
#pool.imap(func,msg)      #非阻塞, 注意与apply传的参数的区别
pool.map(func,msg)        #阻塞print‘Mark~~~~~~~~~~~~~~~‘
pool.close()
pool.join()
print‘sub-process done‘

            if
            __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4)
    result = []
    for i in xrange(3):
        msg = "hello %d" %(i)
        result.append(pool.apply_async(func, (msg, )))
    pool.close()
    pool.join()
    for res in result:
        print":::",res.get()
    print"Sub-process(es) done."