def main():
print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
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))
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test',))
print('Child process will start.')
p.start()
p.join()
print('Child process end.')
print '================================'
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
print('$ nslookup www.python.org')
r = subprocess.call(['nslookup', 'www.python.org'])
print('Exit code:', r)
print('$ nslookup')
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode('utf-8'))
print('Exit code:', p.returncode)
def tryforkwindows(n):
if n == 1:
print('Parent process %s.' % os.getpid())
sec = 3
p = Process(target=run_proc, args=('test', sec))
print('Child process will start ...')
p.start()
childlast = 15
while childlast >= 0:
print('# Parent (%s) and its child (%s).' % (os.getpid(), p.pid))
time.sleep(1)
childlast -= 1
# Not successful!
# os.kill(p.pid, signal.CTRL_C_EVENT)
# p.join()
print('Parent (%s) kills child (%s)' % (os.getpid(), p.pid))
p.terminate()
print('Child process end.')
if n == 2:
print('Parent process %s.' % os.getpid())
process_num = 16
p = Pool(process_num)
for i in range(process_num):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
if n == 3:
cmd = 'ping www.baidu.com'
print(cmd)
r = subprocess.call(cmd.split())
print('Exit code = ', r)
if n == 4:
q = Queue()
pw = Process(target=q_write, args=(q,))
pr = Process(target=q_read, args=(q,))
pr.start()
pw.start()
pw.join()
pr.terminate()
return
"""如果要启动大量的子进程，可以用进程池的方式批量创建子进程"""
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')
"""对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
请注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在我的电脑上是4，因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成：
p = Pool(5)
就可以同时跑5个进程。
由于Pool的默认大小是CPU的核数，如果你不幸拥有8核CPU，你要提交至少9个子进程才能看到上面的等待效果。"""
#子进程
"""很多时候，子进程并不是自身，而是一个外部进程。我们创建了子进程后，还需要控制子进程的输入和输出。
subprocess模块可以让我们启动一个子进程,然后控制其输入和输出
下面的例子演示了如何在Python代码中运行命令nslookup www.python.org，这和命令行直接运行的效果是一样的："""
import subprocess
p.join()
print('Child process is end')
print('\n')
def longTimeTask(name):
print('Run task {0} pid is {1}'.format(name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task {0} runs {1:.2f} seconds'.format(name, end - start))
# Pool
if __name__ == '__main__':
print('Parent process is {0}'.format(os.getppid()))
p = Pool(4)
for i in range(5):
p.apply_async(longTimeTask, args=(i,))
print('Waiting all subprocess down')
p.close()
p.join()
print('All process down')
print('\n')
# subprocess
if __name__ == '__main__':
print('$ nslookup www.python.org')
r = subprocess.call(['nslookup', 'www.python.org'])
print('Exit code:', r)
#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()
# 共享实例模板
from multiprocessing import Pool, Value, Lock, Manager
import os, time, random
def long_time_task(name, requestCount, countList):
requestCount.value = requestCount.value + 1
print u"计数:", requestCount.value
countList.append(requestCount.value)
import os, time, random
def long_time_task(name): #每个进程池执行的内容
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__ == '__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4) # 代表最多同时执行几个进程，同时是瞬时，看的是cpu的核心数，所以cpu不够太高应该也没有
# task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的大小是4，因此，最多同时执行4个进程。
# Pool的默认大小是CPU的核数，
for i in range(5):
p.apply_async(long_time_task, args=(i, )) #创建并启动所有子进程
print('Waiting for all subprocesses done...')
p.close()
p.join(
) # 对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了
print('All subprocesses done.')
# 运行结果
# Parent process 888.
# Child process will start.
# Run child process test (25688)...
# Child process end.
# Parent process 888.
# Waiting for all subprocesses done...
# Run task 0 (50828)...
# Run task 1 (26584)...
# Run task 2 (28356)...
print("child process end.")
#线程池
import time,random
from multiprocessing import Pool
def long_time_task(name):
print("child process %s(%s,%s) run"%(name,os.getpid(),os.getppid()))
start=time.time()
time.sleep(random.random()*3)
end=time.time()
print("Tast %s runs %0.2f seconds."%(name,end-start))
if __name__=="__main__":
print("Parent process %s"%os.getpid())
p=Pool(5)
for i in range(10):
p.apply_async(long_time_task,args=(i,)) #子进程是本身
print("Waiting for all Processing done...")
p.close()
p.join()
print('All subprocesses done.')
#子进程不是本身
import subprocess
print("nslookup rrs.focushow.cn")
r=subprocess.call("nslookup rrs.focushow.cn")
print("Exit code:%d"%r)
#进程间的通信
#Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。
p.join() # 等待子进程结束后再继续往下运行
print("Child process end.")
print("#" * 80)
"""
Pool 进程池，用于批量创建子进程
"""
from multiprocessing import Pool
import time, random
def long_time_task(name):
print("run task %s (%s)..." % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print("Task %s runs %0.2f senconds.." % (name, (end - start)))
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i, )) # 非阻塞方式。任务的执行不会阻塞任务的添加到进程池中
# p.apply(long_time_task, args=(i,)) # 阻塞方式，等到上一个任务即这里的long_time_task执行完了才能继续添加
print("waiting for all subProcess finish...")
p.close() # 关闭进程池，光比后P不在接受新的任务或请求
p.join() # 等待P中的所有子进程执行完成，必须放在close语句之后。
print("All subProcess finished")
print("#" * 80)
# 等待进程执行完后再往下执行，用于同步
p.join()
print("--- child process end ---")
#print3
print("===========创建子进程：Pool,进程池中批量创建子进程==========")
def batchProc(name):
print("run sub-process name:%s , id:%s..." % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print("sub-process (%s : %s) running last %s ..." % (name, os.getpid(),
(end - start)))
if __name__ == '__main__':
print("Pool,parent progress (%s)" % os.getpid())
# Pool默认大小（同时执行的进程数）是CPU核数。
p = Pool(6)
for i in range(6):
# 每个子进程执行的时候，都会把print3打印一遍
p.apply_async(batchProc, args=(i, ))
print("waiting for all sub-process done ...")
# 调用close之前必须先调用close，close之后就不能添加新的process了。
p.close()
# 等待所有子进程执行完毕
p.join()
print("---- END ----")
if __name__ == '__main__':
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test', ))
print('Child process will start.')
p.start()
p.join()
print('Child process end.')
#要启动大量的子进程，用进程池的方式创建子进程
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__ == '__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task,
args=(i, )) #apply_async是异步非阻塞的，不用等待当前进程执行完毕
print('Waiting for all subprocesses done')
p.close()
p.join()
print("All subprocesses done.")
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test', )) # 创建一个进程实例
print('Child process will start.')
p.start() # 用start()方法启动
p.join() # join()方法等待子进程结束后再继续往下运行，通常用于进程间的同步
print('Child process end.')
# 2.1 进程池 Pool
print('ABC')
def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3) # time.sleep 方法为推迟执行一定秒数
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__ == '__main__':
print('Parent process %s.' % os.getpid())
p = Pool(9) # 限制同时运行的进程数最多为9个，默认大小是CPU核数
for i in range(8):
p.apply_async(
long_time_task,
args=(i, )) # apply_async 是异步非阻塞，不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。
print('Waiting for all subprocesses done...')
p.close() # close 方法后不能继续添加新的子进程了
p.join()
print('All subprocesses done.')
import os, time, random
def pool_task(taskID):
start = time.time()
print("=== pool_task 线程：%s === 开始时间：%d"%(os.getpid(), start))
time.sleep(random.random() * 3)
print("执行任务：",taskID)
end = time.time()
print("=== pool_task 线程：%s === 结束时间：%d"%(os.getpid(), end))
print("执行时间：",(end - start))
p = Pool(4)
for i in range(5):
p.apply_async(pool_task, args=(i,))
print("准备执行子线程程序！")
p.close()
p.join()
print("所有子线程已经执行完毕")
# 准备执行子线程程序！
# === pool_task 线程：38658 === 开始时间：1494832956
# === pool_task 线程：38659 === 开始时间：1494832956
# === pool_task 线程：38660 === 开始时间：1494832956
# === pool_task 线程：38661 === 开始时间：1494832956
# 执行任务： 1
# === pool_task 线程：38659 === 结束时间：1494832957
# 执行时间： 1.2386257648468018
# === pool_task 线程：38659 === 开始时间：1494832957
from multiprocessing import Pool
def long_time_task(name):
print("child process %s(%s,%s) run" % (name, os.getpid(), os.getppid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print("Tast %s runs %0.2f seconds." % (name, end - start))
if __name__ == "__main__":
print("Parent process %s" % os.getpid())
p = Pool(5)
for i in range(10):
p.apply_async(long_time_task, args=(i, )) #子进程是本身
print("Waiting for all Processing done...")
p.close()
p.join()
print('All subprocesses done.')
#子进程不是本身
import subprocess
print("nslookup rrs.focushow.cn")
r = subprocess.call("nslookup rrs.focushow.cn")
print("Exit code:%d" % r)
#进程间的通信
#Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。
#Python的multiprocessing模块包装了底层的机制，
# multiprocessing.Pool 进程池
#############################
from multiprocessing import Pool
def run_proc_1(*args, **kw):
start = time.time()
time.sleep(random.random() * 2)
print(' [%s] job done, time used %s' % (os.getpid(), time.time() - start))
print('====== multiprocessing.Pool ======')
p = Pool(3)
start = time.time()
for i in range(5):
p.apply_async(run_proc_1)
p.close() # 调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
p.join()
print('time used: %s' % (time.time() - start))
#############################
# subporcess: 用于调用外部程序
#############################
import subprocess
print('====== subprocess ======')
# 查询 baidu ip
print('$ nslookup www.baidu.com')
r = subprocess.call(['nslookup', 'www.baidu.com'])
print('Exit code:', r)
