fork()函数,属于linux内建函数,并且只在Linux系统下存在。它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后分别在父进程和子进程内返回。子进程永远返回0,而父进程返回子进程的PID。这样做的理由是,一个父进程可以fork()出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID,子进程只需要调用os.getpid()函数可以获取自己的进程号。
#!/user/bin/python
#encoding=utf-8
import os
print (os.getpid()) #主进程的id
pid = os.fork() #创建一个子进程,只能在linux下运行
print (pid) #子进程id和0
if pid == 0:
print ('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
print ('I (%s) just created a child process (%s).' % (os.getpid(), pid))
#运行后可见效果,更容易理解
multiprocessing模块就是跨平台版本的多进程管理包,支持子进程、通信和共享数据、执行不同形式的同步
Multiprocessing模块创建进程使用的是Process类
Process类的构造方法:
help(multiprocessing.Process)
__init__(self, group=None, target=None, name=None, args=(), kwargs={})
参数说明:
group:进程所属组,基本不用。
target:表示调用对象,一般为函数。
args:表示调用对象的位置参数元组。
name:进程别名。
kwargs:表示调用对象的字典。
思路:
1.生成子进程,给它指定一个完成的任务(一个函数)
2.生成所有的子进程,并start
3.join一下所有的子进程,等待所有的子进程执行完毕了,在执行主进程的剩余代码
代码示例1:
#encoding:utf-8
import multiprocessing
def do(n) :
#获取当前线程的名字
name = multiprocessing.current_process().name
print(name,'starting')
print("worker ", n)
return
if __name__ == '__main__' :
numList = []
for i in range(5) :
p = multiprocessing.Process(target=do, args=(i,))
numList.append(p) #将子进程对象添加在列表中
p.start() #启动进程
#p.join() #p进程,通过join方法通知主进程死等我结束,再继续执行,相当于顺序执行了
for i in numList:
i.join() #每一个子进程执行结束后,开始下一个循环,待子进程全部执行完毕,再执行主进程
print("Process end.")
代码示例2:5个进程,新建5个文件,每个文件写100行自定义的文字
#encoding:utf-8
import multiprocessing
def writeContent(filepath):
with open(filepath,"w") as fp:
for i in range(100):
fp.write("glory"+str(i)+"\n")
if __name__=="__main__":
pList=[]
for i in range(1,6):
p=multiprocessing.Process(target=writeContent,args=("test"+str(i)+".txt",))
pList.append(p)
p.start()
for p in pList:
p.join()
print ("程序运行成功!")
#!/usr/bin/python
# -*- coding: utf-8 -*-
from multiprocessing import Process
import os
import time
def sleeper(name, seconds):
print("Process ID# %s" % (os.getpid())) #获取当前进程
print("Parent Process ID# %s" % (os.getppid())) #获取当前进程的父进程
print("%s will sleep for %s seconds" % (name, seconds))
time.sleep(seconds)
child_proc = Process(target = sleeper, args = ('bob', 5))
child_proc.start()
print("in parent process after child process start")
print("parent process about to join child process")
child_proc.join()
print("in parent process after child process join" )
print("the parent's parent process: %s" % (os.getppid()))
#coding=utf-8
import multiprocessing
import urllib.request
import time
def func1(url) :
response = urllib.request.urlopen(url)
html = response.read()
print(html[0:20])
time.sleep(1)
def func2(url) :
response = urllib.request.urlopen(url)
html = response.read()
print(html[0:20])
time.sleep(1)
if __name__ == '__main__' :
p1 = multiprocessing.Process(target=func1,args=("http://www.sogou.com",),name="gloryroad1")
p2 = multiprocessing.Process(target=func2,args=("http://www.baidu.com",),name="gloryroad2")
p1.start()
p2.start()
p1.join()
p2.join()
time.sleep(1)
print("done!")
#coding: utf-8
import multiprocessing
import time
def m1(x):
time.sleep(0.05)
return x * x
if __name__ == '__main__':
#多进程执行
pool = multiprocessing.Pool(multiprocessing.cpu_count()) #进程池,内核有几个就有几个进程
i_list = range(1000)
time1=time.time()
pool.map(m1, i_list)
time2=time.time()
print('time elapse:',time2-time1)
#单进程执行
time1=time.time()
list(map(m1, i_list))
time2=time.time()
print('time elapse:',time2-time1)
在使用Python进行系统管理时,特别是同时操作多个文件目录或者远程控制多台主机,并行操作可以节约大量的时间。如果操作的对象数目不大时,还可以直接使用Process类动态的生成多个进程,十几个还好,但是如果上百个甚至更多,那手动去限制进程数量就显得特别的繁琐,此时进程池就派上用场了。
Pool类可以提供指定数量的进程供用户调用,当有新的请求提交到Pool中时,如果池还没有满,就会创建一个新的进程来执行请求。如果池满,请求就会告知先等待,直到池中有进程结束,才会创建新的进程来执行这些请求。
apply_async()
函数原型:apply_async(func, args=(), kwds={}, callback=None, error_callback=None)
异步非阻塞的,不用等待当前进程执行完毕,随时根据系统调度来进行进程切换(建议使用)
注意:apply_async每次只能提交一个进程的请求
map()
函数原型:map(func, iterable[, chunksize=None])
Pool类中的map方法,与内置的map函数用法行为基本一致,它会使进程阻塞直到返回结果。
注意,虽然第二个参数是一个迭代器,但在实际使用中,必须在整个队列都就绪后,程序才会运行子进程。
close()
关闭进程池(Pool),使其不再接受新的任务
terminate()
立刻结束工作进程,不再处理未处理的任务
join()
使主进程阻塞等待子进程的退出,join方法必须在close或terminate之后使用
multiprocessing.cpu_count()
获取cup的核数
代码示例一:使用进程池创建进程+map函数
#encoding:utf-8
import multiprocessing
import os
import time
import random
def func(x):
time.sleep(random.random()*4)
print ("pid:",os.getpid(),x*x)
#print (os.getppid())
return x*x
if __name__=="__main__":
pool=multiprocessing.Pool(multiprocessing.cpu_count())
i_list=range(8)
print (pool.map(func,i_list))
代码示例二:apply_async() 只能创建一个任务且执行一次
#encoding=utf-8
from multiprocessing import Pool
def f(x):
return x * x
if __name__ == '__main__':
pool = Pool(processes = 4) # start 4 worker processes
result = pool.apply_async(f, [10]) # 只能创建一个任务,且执行一次,可以传多个参数,根据函数的参数来定
print(result) #ApplyResult object
print(result.get(timeout = 1)) #获取值
print(pool.map(f, range(10)))
代码示例三:实现给pool.map中的函数传递多个参数
#encoding=utf-8
from multiprocessing import Pool
“实现思想:定义一个类,有多个实例变量;然后定义一个函数,参数为类的实例,最后对类实例的实例变量进行运算”
def f(object):
return object.x * object.y
class A:
def __init__(self,a,b):
self.x =a
self.y =b
if __name__ == '__main__':
pool = Pool(processes = 4) # start 4 worker processes
params = [A(i,i) for i in range(10)] #推导列表生成实例列表
#print (params) #打印实例列表
print(pool.map(f,params))
代码示例四:多进程与单进程执行时间比较
#encoding=utf-8
import time
from multiprocessing import Pool
def run(fn):
#fn: 函数参数是数据列表的一个元素
time.sleep(1)
return fn * fn
if __name__ == "__main__":
testFL = [1,2,3,4,5,6] #testFL:要处理的数据列表
#顺序执行花费的时间
print ('Single process execution sequence:')
s = time.time()
for fn in testFL:
run(fn)
e1 = time.time()
print (u"顺序执行时间:", int(e1 - s))
#创建多个进程,并行执行花费的时间
print ('concurrent:')
pool = Pool(5) #创建拥有5个进程数量的进程池,假设核数就是4个,轮询处理4个,
rl =pool.map(run, testFL)
pool.close() #关闭进程池,不再接受新的任务
pool.join() #主进程阻塞等待子进程的退出
e2 = time.time()
print (u"并行执行时间:", int(e2 - e1))
multiprocessing.Queue类似于queue.Queue,一般用来多个进程间交互信息。Queue是进程和线程安全的。它实现queue.Queue的大部分方法,但task_done()和join()没有实现。
multiprocessing.JoinableQueue是multiprocessing.Queue的子类,增加了task_done()方法和join()方法。
task_done():用来告诉queue一个task完成。一般在调用get()时获得一个task,在task结束后调用task_done()来通知Queue当前task完成。
join():阻塞直到queue中的所有的task都被处理(即task_done方法被调用)。
代码示例一:
#encoding=utf-8
from multiprocessing import Process, Queue
def offer(queue):
"入队列"
if queue.empty():
queue.put("Hello World")
else:
print(queue.get())
if __name__ == '__main__':
# 创建一个队列实例
q = Queue()
p = Process(target = offer, args = (q,))
p.start()
print(q.get()) # 出队列
q.put("tester")
m = Process(target = offer, args = (q,))
m.start()
p.join()
m.join()
代码示例二:
#encoding=utf-8
from multiprocessing import Process, Queue
import os, time, random
#写数据进程执行的代码:
def write(q):
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())
# 读数据进程执行的代码
def read(q):
time.sleep(1)
while not q.empty(): #if not q.empty():
print('Get %s from queue.' % q.get(True))
time.sleep(1) #目的是等待写队列完成
if __name__=='__main__':
# 父进程创建Queue,并传给各个子进程
q = Queue()
pw = Process(target = write, args = (q,))
pr = Process(target = read, args = (q,))
pw.start() #启动子进程pw,写入
pr.start() #启动子进程pr,读取
pw.join() #等待pw结束
pr.join() #等待pr结束
print("Done!")
#由于操作系统对进程的调度时间不一样,所以该程序每次执行的结果均不一样。程序读队列函数中为什么要加一句time.sleep(1),
目的是等待写进程将数据写到队列中,防止有时写进程还没将数据写进队列,读进程就开始读了,导致读不到数据。但是这种并不能有效的预防此种情况的出现。
#encoding=utf-8
import multiprocessing
import time
class Consumer(multiprocessing.Process):
def __init__(self, task_queue, result_queue):
multiprocessing.Process.__init__(self)
self.task_queue = task_queue #任务队列
self.result_queue = result_queue #存储结果的结果队列
def run(self):
"重写原进程的run方法"
proc_name = self.name #取到当前进程的名字
while True:
next_task = self.task_queue.get()
if next_task is None: #为None时进程退出
print(('%s: Exiting' % proc_name))
self.task_queue.task_done()
break
print(('%s: %s' % (proc_name, next_task))) #打印next_task,自动调用的__str__方法
answer = next_task()
self.task_queue.task_done() #JoinableQueue特有的一定要执行,返回
self.result_queue.put(answer)
return
class Task(object):
def __init__(self, a, b):
self.a = a
self.b = b
def __call__(self):
time.sleep(0.1) # pretend to take some time to do the work
return '%s * %s = %s' % (self.a, self.b, self.a * self.b)
def __str__(self):
return '%s * %s' % (self.a, self.b)
if __name__ == '__main__':
tasks = multiprocessing.JoinableQueue() #任务队列
results = multiprocessing.Queue() #存结果队列
num_consumers = multiprocessing.cpu_count()
print(('Creating %d consumers' % num_consumers))
# 创建cup核数量数量个的子进程,使用推导列表生成子进程列表
consumers = [ Consumer(tasks, results) for i in range(num_consumers) ]
# 依次启动子进程
#print (consumers)
for w in consumers:
w.start()
num_jobs = 10
for i in range(num_jobs):
tasks.put(Task(i, i))
for i in range(num_consumers):
tasks.put(None) #有几个进程加几个None,以此结束死循环
tasks.join()
while num_jobs:
result = results.get()
print ('Result: %s' %result)
num_jobs -= 1
线程安全:通过加锁的方式避免引起读写操作的冲突,确保数据的一致性(洗手间的例子)
线程不安全:与之相反,会造成数据的混乱
#未加锁处理,py2环境下运行,会出现打印数据错乱的情况
#encoding=utf-8
from multiprocessing import Process
import time
def l(num):
time.sleep(0.2)
print("Hello Num: %s" % (num))
if __name__ == '__main__':
for num in range(50):
Process(target = l, args = (num,)).start()
#不会出现上述错乱的情况
#encoding=utf-8
from multiprocessing import Process, Lock
import time
def l(num,lock):
lock.acquire() # 获得锁
time.sleep(0.2)
print("Hello Num: %s" % (num))
lock.release() # 释放锁
if __name__ == '__main__':
lock = Lock() # 创建一个共享锁实例
for num in range(50):
Process(target = l, args = (num,lock)).start()
Semaphore用于控制对共享资源的访问数量。Semaphore锁和Lock稍有不同,Semaphore相当于N把锁,获取其中一把就可以执行。可用锁的总数N在创建实例时传入,比如s = Semaphore(n)。与Lock一样,如果可用锁为0,进程将会阻塞,直到可用锁大于0。
#encoding=utf-8
import multiprocessing
import time
def worker(s, i):
s.acquire()
print(multiprocessing.current_process().name + " acquire")
time.sleep(i)
print(multiprocessing.current_process().name + " release")
s.release()
if __name__ == "__main__":
# 设置限制最多3个进程同时访问共享资源
s = multiprocessing.Semaphore(3)
for i in range(5):
p = multiprocessing.Process(target = worker, args = (s, i * 2))
p.start()
Event提供一种简单的方法,可以在进程间传递状态信息,实现进程间同步通信。事件可以切换设置和未设置状态。通过使用一个可选的超时值,时间对象的用户可以等待其状态从未设置变为设置
#encoding=utf-8
import multiprocessing
import time
def wait_for_event(e):
print('wait_for_event: starting')
e.wait() #等待收到能执行信号,如果一直未收到将一直阻塞
print('wait_for_event: e.is_set()->', e.is_set())
def wait_for_event_timeout(e, t):
print('wait_for_event_timeout: starting')
e.wait(t) #等待t秒超时,此时Event的状态仍未未设置,继续执行
print('wait_for_event_timeout: e.is_set()->', e.is_set())
e.set() #初始内部标志为真
if __name__ == '__main__':
e = multiprocessing.Event()
print("begin,e.is_set()", e.is_set())
w1 = multiprocessing.Process(name='block', target=wait_for_event, args=(e,))
w1.start()
w2 = multiprocessing.Process(name='nonblock', target=wait_for_event_timeout,args=(e, 2))
w2.start()
print('main: waiting before calling Event.set()')
time.sleep(3)
#e.set() #可注释此句话看效果
print('main: event is set')
代码逻辑:
函数a-wait_for_event:e.wait():死等,等别的进程调用e.set(),才会继续执行
函数b-wait_for_event_timeout:e.wait(t):死等t秒,等别的进程调用e.set()或经过t秒,才会继续执行,继续执行了,就会调用e.set(),实现函数a就可以从死等状态变为继续执行执行状态
主程序:
声明了一个信号对象e
启动了进程a,执行函数a
启动了进程b,执行函数b
支持多个进程,待听到指令后死等的所有进程全部不用等了,比如:田径比赛,所有运动员听到发令枪声,就全都跑了
#encoding=utf-8
import multiprocessing
import time
def wait_for_event(e):
print('wait_for_event: starting')
e.wait()
print('wait_for_event: e.is_set()->', e.is_set())
def wait_for_event_timeout(e, t):
print('wait_for_event_timeout: starting')
e.wait(t)
print('wait_for_event_timeout: e.is_set()->', e.is_set())
e.set()
if __name__ == '__main__':
e = multiprocessing.Event()
print("begin,e.is_set()", e.is_set())
w1 = multiprocessing.Process(name='block', target=wait_for_event, args=(e,))
w1.start()
w2 = multiprocessing.Process(name='block', target=wait_for_event, args=(e,))
w2.start()
w3 = multiprocessing.Process(name='nonblock', target=wait_for_event_timeout,args=(e, 2))
w3.start()
print('main: waiting before calling Event.set()')
time.sleep(3)
#e.set() #可注释此句话看效果
print('main: event is set')
Pipe是两个进程间通信的工具。Pipe可以是单向(half-duplex),也可以是双向(duplex)。我们通过mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从PIPE一端输入对象,然后被PIPE另一端的进程接收,单向管道只允许管道一端的进程输入,而双向管道则允许从两端输入。
Pipe的每个端口同时最多一个进程读写,否则会出现各种问题,可能造成corruption异常。
Pipe对象建立的时候,返回一个含有两个元素的元组对象,每个元素代表Pipe的一端(Connection对象)。我们对Pipe的某一端调用send()方法来传送对象,在另一端使用recv()来接收。
#encoding=utf-8
import multiprocessing as mp
def proc_1(pipe):
pipe.send('hello')
print('proc_1 received: %s' %pipe.recv())
pipe.send("what is your name?")
print('proc_1 received: %s' %pipe.recv())
def proc_2(pipe):
print('proc_2 received: %s' %pipe.recv())
pipe.send('hello, too')
print('proc_2 received: %s' %pipe.recv())
pipe.send("I don't tell you!")
if __name__ == '__main__':
# 创建一个管道对象pipe
pipe = mp.Pipe()
#print(len(pipe))
#print(type(pipe))
#print (pipe)
# 将第一个pipe对象传给进程1
p1 = mp.Process(target = proc_1, args = (pipe[0], ))
# 将第二个pipe对象传给进程2
p2 = mp.Process(target = proc_2, args = (pipe[1], ))
p1.start()
p2.start()
p1.join()
p2.join()
代码实例二:将获取的信息写入文件
#encoding=utf-8
import multiprocessing as mp
from multiprocessing import Process, Lock
def write_file(content,lock,file_path="a.txt"):
lock.acquire()
with open(file_path,"a") as fp:
fp.write(content+"\n")
lock.release()
def proc_1(pipe,lock):
pipe.send('hello')
info = pipe.recv()
print('proc_1 received: %s' %info)
write_file(info,lock)
pipe.send("what is your name?")
info = pipe.recv()
print('proc_1 received: %s' %info)
write_file(info,lock)
def proc_2(pipe,lock):
info = pipe.recv()
print('proc_2 received: %s' %info)
write_file(info,lock)
pipe.send('hello, too')
info = pipe.recv()
write_file(info,lock)
print('proc_2 received: %s' %info)
pipe.send("I don't tell you!")
if __name__ == '__main__':
pipe = mp.Pipe()
lock=Lock()
# 将第一个pipe对象传给进程1
p1 = mp.Process(target = proc_1, args = (pipe[0],lock ))
# 将第二个pipe对象传给进程2
p2 = mp.Process(target = proc_2, args = (pipe[1],lock ))
p1.start()
p2.start()
p1.join()
p2.join()
一个condition变量总是与某些类型的锁相联系,当几个condition变量必须共享同一个锁的时候,是很有用的。锁是conditon对象的一部分:没有必要分别跟踪
condition变量服从上下文管理协议:with语句块封闭之前可以获取与锁的联系。 acquire() 和release() 会调用与锁相关联的相应方法
wait()方法会释放锁,当另外一个进程使用notify() or notify_all()唤醒它之前会一直阻塞。一旦被唤醒,wait()会重新获得锁并返回;
wait(timeout=None) :等待通知,或者等到设定的超时时间;
notify()和notify_all()不会释放锁;
#encoding=utf-8
import multiprocessing as mp
import threading
import time
def consumer(cond):
with cond:
print("consumer before wait")
cond.wait() #等待消费,死等
#cond.wait(timeout=10) #等待10秒后还未消费自动结束
print("consumer after wait")
def producer(cond):
with cond:
print("producer before notifyAll")
cond.notify_all() #通知所有消费者可以消费了
#cond.notify() #只能通知一个消费者,想通知几个人就写几次
print("producer after notifyAll")
if __name__ == '__main__':
condition = mp.Condition()
p1 = mp.Process(name = "p1", target = consumer, args=(condition,))
p2 = mp.Process(name = "p2", target = consumer, args=(condition,))
p3 = mp.Process(name = "p3", target = producer, args=(condition,))
p1.start()
time.sleep(2)
p2.start()
time.sleep(2)
p3.start()
#数据在子进程运行的时候被改变;但是主进程打印的数据仍为原值,互相独立不共享
#encoding=utf-8
from multiprocessing import Process
def f(n, a):
n = n+1
for i in range(len(a)):
a[i] = -a[i]
if __name__ == '__main__':
num = 0
arr =list(range(10))
p = Process(target = f, args = (num, arr))
p.start()
p.join()
print(num)
print(arr[:])
#encoding=utf-8
from multiprocessing import Process, Value, Array
def f(n, a):
n.value = n.value+1
for i in range(len(a)):
a[i] = -a[i]
if __name__ == '__main__':
num = Value('d', 0.0) # 参数"d"(double简写)指定参数类型,创建一个进程间共享的数字类型,默认值为0
arr = Array('i', range(10)) # 创建一个进程间共享的数组类型,初始值为range[10]
p = Process(target = f, args = (num, arr))
p.start()
p.join()
#此时num.value为1.0,arr[:]为[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
p = Process(target = f, args = (num, arr))
p.start()
p.join()
print(num.value) # 获取共享变量num的值
print(arr[:])
#encoding=utf-8
import time
from multiprocessing import Process, Value, Lock
class Counter(object):
def __init__(self, initval = 0):
self.val = Value('i', initval)
self.lock = Lock()
def increment(self):
“如果此处不对共享变量加锁的话,多个进程同时运行的结果每次都不一样”
with self.lock:
self.val.value += 1 # 共享变量自加1
#print(“increment one time!”,self.value() )
def value(self):
with self.lock:
return self.val.value
def func(counter):
for i in range(50):
time.sleep(0.01)
counter.increment()
if __name__ == '__main__':
counter = Counter(0)
procs = [Process(target = func, args = (counter,)) for i in range(10)]
# 等价于
# for i in range(10):
# Process(target = func, args = (counter,))
for p in procs:
p.start()
for p in procs:
p.join()
print(counter.value())
Manager()函数返回一个管理对象,它控制了一个服务端进程,用来保持Python对象,并允许其它进程使用代理来管理这些对象。
#encoding=utf-8
from multiprocessing import Process, Manager, Value
from ctypes import c_char_p
def greet(shareStr):
shareStr.value = shareStr.value + ", World!"
if __name__ == '__main__':
manager = Manager()
shareStr = manager.Value(c_char_p, "Hello")
processList = [Process(target = greet, args = (shareStr,)) for i in range(3)]
for process in processList:
process.start()
process.join()
print(shareStr.value)
#encoding=utf-8
from multiprocessing import Process, Manager
def f(shareDict, shareList):
shareDict[1] = '1'
shareDict['2'] = 2
shareDict[0.25] = None
shareList.reverse() # 翻转列表
if __name__ == '__main__':
manager = Manager()
shareDict = manager.dict() # 创建共享的字典类型
shareList = manager.list(range(10)) # 创建共享的列表类型
p = Process(target = f, args = (shareDict, shareList))
p.start()
p.join()
print(shareDict)
print(shareList)
#encoding=utf-8
import time, os
import random
from multiprocessing import Pool, Value, Lock
from multiprocessing.managers import BaseManager
class MyManager(BaseManager):
pass
def Manager():
m = MyManager()
m.start()
return m
class Counter(object):
def __init__(self, initval=0):
self.val = Value('i', initval)
self.lock = Lock()
def increment(self):
with self.lock:
self.val.value += 1
def value(self):
with self.lock:
return self.val.value
#将Counter类注册到Manager管理类中
MyManager.register('Counter', Counter)
def long_time_task(name,counter):
time.sleep(0.2)
print('Run task %s (%s)...\n' % (name, os.getpid()))
start = time.time()
#time.sleep(random.random() * 3)
for i in range(50):
time.sleep(0.01)
counter.increment()
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__ == '__main__':
manager = Manager()
# 创建共享Counter类实例对象的变量,Counter类的初始值0
counter = manager.Counter(0)
print('Parent process %s.' % os.getpid())
p = Pool()
for i in range(5):
p.apply_async(long_time_task, args = (str(i), counter))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
print(counter.value())
逻辑思路:
继承BaseManager类,生成MyManager子类
定义一个Manager函数,对MyManager类进行实例化,并且启动MyManager的进程,返回MyManager类的实例对象
定义一个Counter类
MyManager.register('Counter', Counter) 将Counter类注册到Manager管理类中
定义多进程执行的任务函数,定义的类实例作为参数传入到任务函数中
在主程序中,定义进程池,for循环启动多个进程,并且每个进程都执行的是之前定义的任务函数
关闭进程池,等待子进程结束后再打印共享实例中的value值