python多进程和多线程一起使用_Python 多进程和多线程

Python中的多进程

Process 逐个创建进程

使用multiprocessing中的Process，其中start()代表启动进程，join()代表等待进程结束再执行后面代码程序。

from multiprocessing import Process

from time import time,sleep

def func(arg):

time.sleep(6)

return arg

def main():

start = time()

p1 = Process(target=func,args=('123',))

p1.start()

p2 = Process(target=func,args=('456',))

p2.start()

p1.join()

p2.join()

end = time()

print('总共耗费了%.2f秒.' % (end - start))

if __name__ == '__main__':

main()

在创建进程时，子进程复制了父进程及其所有的数据结构，每个子进程有独立的内存空间，所以子进程间不共享变量。

Pool 创建指定数量的进程

Pool类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到池中有进程结束，才会创建新的进程来执行这些请求。

使用multiprocessing中的Pool，其中imap()代表函数参数映射，join()代表等待进程结束再执行后面代码程序。

import time

from multiprocessing import Pool

def run(fn):

time.sleep(1)

print(fn * fn)

if __name__ == "__main__":

testFL = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 进程池数目

num_pools = 3

pool = Pool(num_pools)

# testFL:要处理的数据列表，run：处理testFL列表中数据的函数

pool.imap(run, testFL)

# pool.imap_unordered(run, testFL) 随机顺序

pool.close() # 关闭进程池，不再接受新的进程

pool.join() # 主进程阻塞等待子进程的退出

Python中的多线程

使用threading中的Thread线程，其中start()代表启动进程，join()代表等待线程结束再执行后面代码程序。

使用threading中的Lock锁，其中acquire()代表先获取锁才能执行后续，release()代表等待线程结束再执行后面代码程序。

# Python中的多线程

from threading import Thread,Lock

import time

class wallet:

def __init__(self,money):

self.money = money

self._lock = Lock()# 通过“锁”来保护“临界资源”

@property

def _money(self):

return self.money

def dp(self):

self._lock.acquire()

x = self.money - 1

time.sleep(0.01) # 延迟时间

self.money = x

self._lock.release()

class deposit(Thread):

def __init__(self,wt):

super().__init__()

self.wt = wt

def run(self):# 线程执行函数run

self.wt.dp()

def main():

wt = wallet(100)

threads = []

for i in range(100):

t = deposit(wt)

threads.append(t)

t.start()

for t in threads:

t.join()

print("balance: ",wt.money)

if __name__ == '__main__':

main()