conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法

conn1.fileno():返回连接使用的整数文件描述符

conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    

conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

from multiprocessing import Process,Pipe

import time,os

def consumer(p,name):

    left,right=p

    left.close()

    while True:

        try:

            baozi=right.recv()

            print('%s 收到包子:%s' %(name,baozi))

        except EOFError:

            right.close()

            break

def producer(seq,p):

    left,right=p

    right.close()

    for i in seq:

        left.send(i)

        # time.sleep(1)

    else:

        left.close()

if __name__ == '__main__':

    left,right=Pipe()

    c1=Process(target=consumer,args=((left,right),'c1'))

    c1.start()

    seq=(i for i in range(10))

    producer(seq,(left,right))

    right.close()

    left.close()

    c1.join()

    print('主进程')

c1 收到包子:0

c1 收到包子:1

c1 收到包子:2

c1 收到包子:3

c1 收到包子:4

c1 收到包子:5

c1 收到包子:6

c1 收到包子:7

c1 收到包子:8

c1 收到包子:9

主进程

from multiprocessing import Process,Pipe

import time,os

def adder(p,name):

    server,client=p

    client.close()

    while True:

        try:

            x,y=server.recv()

        except EOFError:

            server.close()

            break

        res=x+y

        server.send(res)

    print('server done')

if __name__ == '__main__':

    server,client=Pipe()

    c1=Process(target=adder,args=((server,client),'c1'))

    c1.start()

    server.close()

    client.send((10,20))

    print(client.recv())

    client.close()

    c1.join()

    print('主进程')

30

server done

主进程

Pool([numprocess  [,initializer [, initargs]]]):创建进程池

numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值

initializer：是每个工作进程启动时要执行的可调用对象，默认为None

initargs：是要传给initializer的参数组

p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()

p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。

p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成5 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法

obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。

obj.ready():如果调用完成，返回True

obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常

obj.wait([timeout]):等待结果变为可用。

obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

from multiprocessing import Pool

import time

def work(n):

    print('开工啦...')

    time.sleep(3)

    return n**2

if __name__ == '__main__':

    q=Pool()

    #异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果，否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了

    res=q.apply_async(work,args=(2,))

    q.close()

    q.join() #join在close之后调用

    print(res.get())

    #同步apply用法：主进程一直等apply提交的任务结束后才继续执行后续代码

    # res=q.apply(work,args=(2,))

    # print(res)

开工啦...

4

#一：使用进程池（非阻塞,apply_async）

#coding: utf-8

from multiprocessing import Process,Pool

import time

def func(msg):

    print( "msg:", msg)

    time.sleep(1)

    return msg

if __name__ == "__main__":

    pool = Pool(processes = 3)

    res_l=[]

    for i in range(10):

        msg = "hello %d" %(i)

        res=pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

        res_l.append(res)

    print("==============================>") #没有后面的join，或get，则程序整体结束，进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了

    pool.close() #关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成

    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的是<multiprocessing.pool.ApplyResult object at 0x10357c4e0>对象组成的列表,而非最终的结果,但这一步是在join后执行的,证明结果已经计算完毕,剩下的事情就是调用每个对象下的get方法去获取结果

    for i in res_l:

        print(i.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

#二：使用进程池（阻塞,apply）

#coding: utf-8

from multiprocessing import Process,Pool

import time

def func(msg):

    print( "msg:", msg)

    time.sleep(0.1)

    return msg

if __name__ == "__main__":

    pool = Pool(processes = 3)

    res_l=[]

    for i in range(10):

        msg = "hello %d" %(i)

        res=pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去

        res_l.append(res) #同步执行，即执行完一个拿到结果，再去执行另外一个

    print("==============================>")

    pool.close()

    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的就是最终的结果组成的列表

    for i in res_l: #apply是同步的，所以直接得到结果，没有get()方法

        print(i)

#Pool内的进程数默认是cpu核数，假设为4（查看方法os.cpu_count()）

#开启6个客户端，会发现2个客户端处于等待状态

#在每个进程内查看pid，会发现pid使用为4个，即多个客户端公用4个进程

from socket import *

from multiprocessing import Pool

import os

server=socket(AF_INET,SOCK_STREAM)

server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

server.bind(('127.0.0.1',8080))

server.listen(5)

def talk(conn,client_addr):

    print('进程pid: %s' %os.getpid())

    while True:

        try:

            msg=conn.recv(1024)

            if not msg:break

            conn.send(msg.upper())

        except Exception:

            break

if __name__ == '__main__':

    p=Pool()

    while True:

        conn,client_addr=server.accept()

        p.apply_async(talk,args=(conn,client_addr))

        # p.apply(talk,args=(conn,client_addr)) #同步的话，则同一时间只有一个客户端能访问

server端

server端

from socket import *

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8080))

while True:

    msg=input('>>: ').strip()

    if not msg:continue

    client.send(msg.encode('utf-8'))

    msg=client.recv(1024)

    print(msg.decode('utf-8'))

客户端

from multiprocessing import Pool

import time,random,os

def work(n):

    time.sleep(1)

    return n**2

if __name__ == '__main__':

    p=Pool()

    res_l=[]

    for i in range(10):

        res=p.apply_async(work,args=(i,))

        res_l.append(res)

    p.close()

    p.join() #等待进程池中所有进程执行完毕

    nums=[]

    for res in res_l:

        nums.append(res.get()) #拿到所有结果

    print(nums) #主进程拿到所有的处理结果,可以在主进程中进行统一进行处理

from multiprocessing import Pool

import time,random,os

def get_page(url):

    print('(进程 %s) 正在下载页面 %s' %(os.getpid(),url))

    time.sleep(random.randint(1,3))

    return url #用url充当下载后的结果

def parse_page(page_content):

    print('<进程 %s> 正在解析页面: %s' %(os.getpid(),page_content))

    time.sleep(1)

    return '{%s 回调函数处理结果:%s}' %(os.getpid(),page_content)

if __name__ == '__main__':

    urls=[

        'http://maoyan.com/board/1',

        'http://maoyan.com/board/2',

        'http://maoyan.com/board/3',

        'http://maoyan.com/board/4',

        'http://maoyan.com/board/5',

        'http://maoyan.com/board/7',

    ]

    p=Pool()

    res_l=[]

    #异步的方式提交任务,然后把任务的结果交给callback处理

    #注意:会专门开启一个进程来处理callback指定的任务(单独的一个进程,而且只有一个)

    for url in urls:

        res=p.apply_async(get_page,args=(url,),callback=parse_page)

        res_l.append(res)

    #异步提交完任务后,主进程先关闭p(必须先关闭),然后再用p.join()等待所有任务结束(包括callback)

    p.close()

    p.join()

    print('{主进程 %s}' %os.getpid())

    #收集结果,发现收集的是get_page的结果

    #所以需要注意了:

    #1. 当我们想要在将get_page的结果传给parse_page处理,那么就不需要i.get(),通过指定callback,就可以将i.get()的结果传给callback执行的任务

    #2. 当我们想要在主进程中处理get_page的结果,那就需要使用i.get()获取后,再进一步处理

    for i in res_l: #本例中,下面这两步是多余的

        callback_res=i.get()

        print(callback_res)

'''

打印结果:

(进程 52346) 正在下载页面 http://maoyan.com/board/1

(进程 52347) 正在下载页面 http://maoyan.com/board/2

(进程 52348) 正在下载页面 http://maoyan.com/board/3

(进程 52349) 正在下载页面 http://maoyan.com/board/4

(进程 52348) 正在下载页面 http://maoyan.com/board/5

<进程 52345> 正在解析页面: http://maoyan.com/board/3

(进程 52346) 正在下载页面 http://maoyan.com/board/7

<进程 52345> 正在解析页面: http://maoyan.com/board/1

<进程 52345> 正在解析页面: http://maoyan.com/board/2

<进程 52345> 正在解析页面: http://maoyan.com/board/4

<进程 52345> 正在解析页面: http://maoyan.com/board/5

<进程 52345> 正在解析页面: http://maoyan.com/board/7

{主进程 52345}

http://maoyan.com/board/1

http://maoyan.com/board/2

http://maoyan.com/board/3

http://maoyan.com/board/4

http://maoyan.com/board/5

http://maoyan.com/board/7

'''

from multiprocessing import Pool

import time,random

import requests

import re

def get_page(url,pattern):

    response=requests.get(url)

    if response.status_code == 200:

        return (response.text,pattern)

def parse_page(info):

    page_content,pattern=info

    res=re.findall(pattern,page_content)

    for item in res:

        dic={

            'index':item[0],

            'title':item[1],

            'actor':item[2].strip()[3:],

            'time':item[3][5:],

            'score':item[4]+item[5]

        }

        print(dic)

if __name__ == '__main__':

    pattern1=re.compile(r'<dd>.*?board-index.*?>(\d+)<.*?title="(.*?)".*?star.*?>(.*?)<.*?releasetime.*?>(.*?)<.*?integer.*?>(.*?)<.*?fraction.*?>(.*?)<',re.S)

    url_dic={

        'http://maoyan.com/board/7':pattern1,

    }

    p=Pool()

    res_l=[]

    for url,pattern in url_dic.items():

        res=p.apply_async(get_page,args=(url,pattern),callback=parse_page)

        res_l.append(res)

    for i in res_l:

        i.get()

    # res=requests.get('http://maoyan.com/board/7')

    # print(re.findall(pattern,res.text))