进程池

from multiprocessing import Pool,Process
import time
def func(n):
    for i in range(10):
        print(n+1)


if __name__ == '__main__':
    st1 = time.time()
    pool = Pool(5)
    pool.map(func,range(100))
    t1 = time.time() - st1

    st2= time.time()
    p_lst = []
    for i in range(100):
        p = Process(target=func,args=(i,))
        p_lst.append(p)
        p.start()
    for p in p_lst: p.join()
    t2 = time.time() - st2
    print(t1,t2)

 

import time,os
from multiprocessing import Pool

def func(n):
    print('start func%s'%n,os.getpid())
    time.sleep(1)
    print('end func%s'%n,os.getpid())

if __name__ == '__main__':
    p = Pool(5)
    for i in range(20):
        p.apply_async(func,args=(i,))
    p.close()
    p.join()

import socket
from multiprocessing import Pool

def func(conn):
    conn.send(b'hello')
    print(conn.recv(1024).decode('utf-8'))
    conn.close()


if __name__ =='__main__':
    sk = socket.socket()
    sk.bind(('127.0.0.1',8080))
    sk.listen()
    p = Pool(5)
    while True:
        conn,addr = sk.accept()
        p.apply_async(func,args=(conn,))

    sk.close()

import socket

sk = socket.socket()
sk.connect(('127.0.0.1',8080))
msg = sk.recv(1024).decode('utf-8')
print(msg)
msg2 = input('>>>').encode('utf-8')
sk.send(msg2)

sk.close()

 

from multiprocessing import Pool
import time
def func(i):
    time.sleep(0.5)
    return i*i

if __name__ == '__main__':
    pool = Pool(5)
    res_l = []
    for i in range(10):
        res = pool.apply_async(func,args=(i,))
        res_l.append(res)
    for res in res_l:print(res.get())

 

from multiprocessing import Pool
import time
def func(i):
    time.sleep(0.5)
    return i*i

if __name__ == '__main__':
    pool = Pool(5)
    ret = pool.map(func,range(10))
    print(ret)

 

from multiprocessing import Pool
import time,os

def func1(n):
    print('in func1',os.getpid())
    return n*n

def func2(nn):
    print('in func2',os.getpid())
    print(nn)

if __name__ == '__main__':
    print('主进程：',os.getpid())
    pool = Pool(5)
    pool.apply_async(func1,args=(10,),callback=func2)
    pool.close()
    pool.join()

 

from multiprocessing import Pool
import time,os

def func1(n):
    return n+1

def func2(nn):
    print(nn)

if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10,20):
        pool.apply_async(func1,args=(i,),callback=func2)
    pool.close()
    pool.join()

 

import requests
from multiprocessing import Pool

def get(url):
    response = requests.get(url)
    if response.status_code == 200:
        return url,response.content.decode('utf-8')
    

def call_back(args):
    url,content = args
    print(url,len(content))

if __name__ == '__main__':
    url_lst = [
        'https://www.cnblogs.com/',
        'http://www.baidu.com',
        'https://www.sogou.com/',
        'http://www.sohu.com/',
    ]
    p = Pool(5)
    for url in url_lst:
        p.apply_async(get,args=(url,),callback=call_back)
    p.close()
    p.join()

 

# 回调函数是在主进程中执行的
from multiprocessing import Pool
def func1(n):
    return n+1

def func2(m):
    print(m)

if __name__ == '__main__':
    p = Pool(5)
    for i in  range(10,20):
        p.apply_async(func1,args=(i,),callback=func2)
    p.close()
    p.join()

 

import re
from urllib.request import urlopen
from multiprocessing import Pool

def get_page(url,pattern):
    response=urlopen(url).read().decode('utf-8')
    return pattern,response

def parse_page(info):
    pattern,page_content=info
    res=re.findall(pattern,page_content)
    for item in res:
        dic={
            'index':item[0].strip(),
            'title':item[1].strip(),
            'actor':item[2].strip(),
            'time':item[3].strip(),
        }
        print(dic)
if __name__ == '__main__':
    regex = r'<dd>.*?<.*?class="board-index.*?>(\d+)</i>.*?title="(.*?)".*?class="movie-item-info".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>'
    pattern1=re.compile(regex,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()

 

from multiprocessing import Pool
import os,time,random

def worker(i):
    t_start = time.time()
    print('%s开始执行，进程号为%s'%(i,os.getpid()))
    time.sleep(random.randint(1,3))
    t_stop = time.time()
    print(i,'执行完毕,耗时%d'%(t_stop-t_start))

if __name__ == '__main__':
    pool = Pool(3)
    for i in range(10):
        pool.apply_async(worker,(i,))

    print('----start----')
    pool.close()
    pool.join()
    print('----end----')