Python Process.apply_async方法代码示例

# 需要导入模块: from multiprocessing import Process [as 别名]
# 或者: from multiprocessing.Process import apply_async [as 别名]
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 Process [as 别名]
# 或者: from multiprocessing.Process import apply_async [as 别名]
"""如果要启动大量的子进程，可以用进程池的方式批量创建子进程"""
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

# 需要导入模块: from multiprocessing import Process [as 别名]
# 或者: from multiprocessing.Process import apply_async [as 别名]
    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)

# 需要导入模块: from multiprocessing import Process [as 别名]
# 或者: from multiprocessing.Process import apply_async [as 别名]
	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之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。