#coding: utf-8
"""
学习进程池使用 multiprocessing.Pool
总结:
  1. Pool 池用于处理 多进程，并不是多线程
  2. 池有大小的概念
  3. 并不是所有的子进程添加完了，才开始启动子进程。 当第一个进程添加到池中的时候，马上就启动了

使用:
  1. 创建进程池对象 pool = multiprocessing.Pool(processes = 3)
  2. 往池中添加进程  主要:pool.apply_async(func, (参数, )) or pool.apply(func, (参数, ))
  3. 调用 pool.close(); pool.join() (一般伴随 apply_async)，等待所有子进程结束

其他：
terminate()    结束工作进程，不再处理未完成的任务
map(...) 将一个集合数据 映射到 同一个函数，  根据集合大小 执行多次子进程
get()  从子进程获取返回结果
"""
import multiprocessing
import time

# 进程代码
def func(msg):
    print "sub begin:", msg
    time.sleep(2)
    print "sub end:",msg

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes = 3) # 创建进程池
    for i in xrange(5):
        msg = " %d" %(i)

        #  apply_async 非阻塞,一般和join一起使用, apply 阻塞 主进程等待子进程一个接一个执行完
        #  apply_async 维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        #  apply_async 这里创建的都是守护进程
        pool.apply_async(func, (msg, ))  # 实际开发中，每个子线程执行不同的逻辑
        time.sleep(1)
        print "alread start sub,%d\n" % i

    print "Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~"
    pool.close() # 关闭pool使其不在接受新的任务，必须有
    pool.join()  # 等待所有子进程结束  调用join之前，先调用close函数，
    print "Sub-process(es) done."

"""
pool.apply_async
Out:

sub begin:  0
alread start sub,0

sub begin:  1
alread start sub,1

sub begin:  2
sub end:  0
sub end:  1alread start sub,2


sub begin:  3
alread start sub,3

sub begin:  4
sub end:  2
sub end:alread start sub,4
 3

Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
sub end:  4
Sub-process(es) done.

"""

"""
pool.apply
Out:

sub begin:  0
sub end:  0
alread start sub,0

sub begin:  1
sub end:  1
alread start sub,1

sub begin:  2
sub end:  2
alread start sub,2

sub begin:  3
sub end:  3
alread start sub,3

sub begin:  4
sub end:  4
alread start sub,4

Mark~ Mark~ Mark~~~~~~~~~~~~~~~~~~~~~~
Sub-process(es) done.

"""

# -*- coding: utf-8 -*-
"""
使用 multiprocessing.Pool.map 执行多进程

逻辑：
   有10个大小的列表，进程池4个大小
   使用map执行完

总结：
   可以简化启动子进程代码

使用:
    1. 创建进程池对象 pool = multiprocessing.Pool(processes = 3)
    2. 准备list 数据  i_list = range(10)
    3. 准备子进程执行代码 函数 sub_process_code
    4. 调用 pool.map(sub_process_code, i_list)
       或
            pool.map_async(sub_process_code, i_list)
            pool.close()
            pool.join()

"""
import multiprocessing
import time
import os
def sub_process_code(x):
    # 打印  hh:ss 编号 进程ID
    print time.strftime(‘%M:%S‘,time.localtime(time.time())),x * x,os.getpid()
    time.sleep(3)

if __name__ == ‘__main__‘:
    pool = multiprocessing.Pool(multiprocessing.cpu_count()) # 根据CPU数量创建进程池，这里是4个
    i_list = range(10)
    pool.map(sub_process_code, i_list)

    ## 下面3行代码 = 上面一行代码
    # pool.map_async(sub_process_code, i_list) # 异步
    # pool.close()
    # pool.join()  # 如果没有join，主进程 结束后，所有子进程马上结束了
    print "end"

"""
Out:

24:20 0 5960
24:20 1 5840
24:20 4 5892
24:20 9 6944
24:23 16 5960
24:23 25 5840
24:23 36 5892
24:23 49 6944
24:26 64 5960
24:26 81 5840
end

"""

# -*- coding: utf-8 -*-
"""
使用进程池 multiprocessing.Pool，获取子进程的返回数据

使用:
    1. 创建进程池对象 pool = multiprocessing.Pool(processes = 3)
    2. 往池中添加进程，同时拿到Result对象 p_ApplyResult_obj = pool.apply_async(func, (参数, ))
    3. 调用 pool.close(); pool.join() 等待所有子进程结束
    4. 获取子进程的返回数据  p_ApplyResult_obj.get()
"""

import multiprocessing
import time

#  子进程代码，会return 数据给主进程
def func(msg):
    time.sleep(3)
    print "end"
    return "return " + msg

if __name__ == "__main__":
    pool = multiprocessing.Pool(processes=4)
    result = []   # 存储Result对象

    for i in xrange(3):
        msg = "hello %d" %(i)
        # 添加子进程的同时，获取它的返回对象
        p_ApplyResult_obj = pool.apply_async(func, (msg, ))
        print id(p_ApplyResult_obj)  # 打印pool对象 ID
        result.append(p_ApplyResult_obj)
    pool.close()
    pool.join()
    for res in result:
        print ":::", res.get()   # 获取子进程的return结果
    print "Sub-process(es) done."

"""
Out:

41974752
41974864
41975032
endend

end
::: return hello 0
::: return hello 1
::: return hello 2
Sub-process(es) done.
"""