python-多进程学习笔记-python黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

恋爱后女盆友的变化

760

文章

656678

访问

+关注

分类

暂无分类

日期归档

2024-11(2)

python-多进程学习笔记

发布于2020-03-12 16:00 阅读(1621) 评论(0) 点赞(24) 收藏(0)

使用模块

multiprocessing

简单例子

import multiprocessing

def test(n):
    name = multiprocessing.current_process().name
    print(name,"starting")
    print("is",n)
    return

if __name__ == '__main__':
    num_list =[]
    for i in range(10):
        p = multiprocessing.Process(target=test,args=(i,))
        num_list.append(p)
        p.start()
        #join是阻塞主进程等待子进程返回
        p.join()
        print(multiprocessing.cpu_count())
        print("End")
    print(num_list)

上面的例子中使用multiprocessing中的Process来创建进程，target为执行的方法，传入函数，args为方法需要传入的参数，此外还可设置group,name等，group一般不会用到，join为阻塞主进程，cpu_count()来获取copu的核数。name来命名子进程。进程有创建，就绪，运行，阻塞与结束共5个状态，start()方法为就绪并不是运行，告知CPU让系统来进行调度安排。

进程池的使用

from multiprocessing import Pool

def func(n):
    return n**2

if __name__ == '__main__':
    pool = Pool(processes=4)
    #异步非阻塞
    result = pool.apply_async(func,[10])
    print(result.get(timeout=1))
    print(pool.map(func,range(10)))

processes意思为开4个进程，一个cpu开一个进程，apply_async为异步启动，如一个任务有4个步骤，使用异步的话就不需要按顺序执行，执行1的同时可以执行2，不需要等待。进程池里还有close()和join()、map()等方法，close()为禁止往进程池添加任务，join()与普通的多进程相仿，map(func,iterate)与python中的map一样迭代队列执行func。

多进程队列

from multiprocessing import Process,Queue
def set_data(queue):
    for i in range(10):
        queue.put("hello"+str(i))

def get_data(queue):
    for i in range(10):
        print(queue.get())

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=set_data,args=(q,))
    p2 = Process(target=get_data,args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print("空...空了吗？",q.empty())

一个进程往队列添加数据，一个进程取走数据，使用这种方法在爬虫之中，可以一个进程存储未爬取的url，一个进程获取，来提高爬取数据的速度。

进程锁

from multiprocessing import Process,Lock,Semaphore

def test_lock(lock,n):
    lock.acquire()#获得锁
    print("this is ",n)
    lock.release()#最后解锁释放

if __name__ == '__main__':
    lock = Lock()
    # s = Semaphore(3)
    for i in range(10):
        Process(target=test_lock,args=(lock,i)).start()

在多进程中，可能在同一时间对一个变量进行访问修改，这时候需要加把锁来锁住，防止一边在修改并且提交了修改后的数据，另一边访问到未修改前的数据并对其修改。加锁可以保证数据的稳定性与安全性，multiprocessing中有2种方式加锁，一种是Lock，一种是Semaphore，后者可以设置同时多少个进程进行访问。

消息传递

from multiprocessing import Process,Event

def wait(event):
    print("wait~~~")
    event.wait()
    print("event.is_set",event.is_set())

def wait_timeout(event,t):
    print("timeout!!!")
    print()
    print("event.is_set", event.is_set())
    event.set()#设置为真

if __name__ == '__main__':
    event = Event()
    print(event.is_set())
    t1 = Process(target=wait,args=(event,))
    t1.start()
    t2 = Process(target=wait_timeout,args=(event,2))
    t2.start()
    print("set event")

在multiprocessing中可以使用Event来进行进程间的通讯，通过is_set()方法来获取当前状态来进行下一步的操作，wait()方法为阻塞等待，如果未接到可执行信号时将一直阻塞。timeout()顾名思义则是超时设置，在超过多少时间后进行信号的设置，然后进行下一步的操作。可以把wait_timeout中的event.set()注释掉来查看具体的效果。

管道

from multiprocessing import Process,Pipe

def p1(pipe):
    pipe.send('pipe1')
    print("pipe1 received： %s"%pipe.recv())
    pipe.send("who are you")
    print("pipe1 received： %s"%pipe.recv())

def p2(pipe):
    pipe.send('pipe2')
    print("pipe2 received： %s"%pipe.recv())
    pipe.send("this is a bad problem")
    print("pipe2 received： %s"%pipe.recv())

if __name__ == '__main__':
    pipe = Pipe()
    #第一个管道对象传入第一个进程
    process1 = Process(target=p1,args=(pipe[0],))
    # 第二个管道对象传入第二个进程
    process2 = Process(target=p2,args=(pipe[1],))
    process1.start()
    process2.start()
    process1.join()
    process2.join()

管道可以看做是两个进程之间进行消息的互通，可以设置单向管道，默认为双向的管道，管道的端口智能由一个进程来使用，否则出现错误。用send来发送消息，recv来接收消息。

多进程共享变量

from multiprocessing import Process,Value,Array

def func(n,a):
    n.value = 200
    for i in range(len(a)):
        a[i] = -a[i]
if __name__ == '__main__':
    num = Value('d',0.0)
    print(num.value)
    arr = Array('i',range(10))
    print(arr[:])
    p = Process(target=func,args=(num,arr))
    p.start()
    p.join()
    print(num.value)
    print(arr[:])