Python_Example_Process 进程 学习/经验/示例

 Author: 楚格

2018-11-16   20:08:32

IDE： Pycharm2018.02   Python 3.7   

KeyWord :  进程 multiprocess Process

Explain:  

--------

# coding=utf-8
#---------------------------------
'''
# Author  : chu ge 
# Function:  进程 学习
#
'''
#---------------------------------
'''
# --------------------------------
# 导入模块 
# 1.系统库
# 2.第三方库
# 3.相关定义库
# --------------------------------
'''
# 1.系统库
import sys
import os
import time
import random

#2.第三方库
from multiprocessing import Process
from multiprocessing import Pool
from multiprocessing import Queue
from multiprocessing import Manager



#
'''
#》》》》》》》》》》
进程

----------------------------------------------
1.进程的创建 
-fork 即 ret  = os.fork()
# window中没有fork，Linux中才有fork

-----------------------
1.1进程VS程序
编写完毕的代码，在没有运行的时候，称为程序;正在运行的代码，成为进程;
进程，除了包含代码之外，还有需要运行环境等，所以和程序有区别

-----------------------
1.2 fork()。python的OS模块，包括fork. 

e.g:
    pid = os.fork()
        if pid == 0:
            print("1")
        else:
            print("2")
说明：
程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），
然后复制父进程的所有信息到子进程中
然后父进程和子进程都会从fork（）函数中得到一个返回值，
在子进程中这个值一定是0，而父进程中是子进程的ID号

在Linux中，fork()系统函数，非常特殊。
普通的函数调用，调用一次，但fork（）调用一次，返回二次，
因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），
然后，分别在父进程和子进程内返回。

-----------------------
1.3子进程永远返回0，而父进程返回子进程的ID
    主进程即父进程
        ret > 0
    新建进程即子进程
        ret = 0
e.g:
    ret = os.fork()
    print(ret)
result:
    2506
    0
    
-----------------------
1.4一个父进程可以fork出很多子进程，所以父进程要记下每个子进程的ID，
而子进程只需要调用.getpid()就可以拿到父进程的ID
getpid() # 获取当前进程的值，子进程获取主进程的ID
getppid()   #获取父进程的ID

e.g:
    ret = os.fork()
    print(ret)
    if ret > 0:
        print("父进程---")
        pritn("%d"%os.getpid())
    else:
        print("子进程--")   
        pritn("%d - %d"%(os.getpid(),os.getppid()))
    
result:
     20570     # 父进程
     父进程---  # 父进程中fork的返回值，
     20569     # 就是刚刚创建出的子进程的ID
     0         # 子进程
     子进程--
     20570 - 20569    

-----------------------
1.5主进程结束不会因为子进程没有结束，而等待子进程
e.g:
    ret = os.fork()
    
    if ret == 0:
        print("--子进程--")
        time.sleep(5)
        print("--子进程 over ---",end="")
    else：
        print("---父进程")
        time.sleep(3)

-----------------------
1.6全局变量在多个进程中，不共享多进程修改全局变量
e.g:
    g_num = 100
    ret = os.fork()
    
    if ret == 0:
        print("--process 1--")
        g_num +=1
        print("--process 1 ==%d"% g_num)
    else:
        time.sleep(3)
        print("---process 2 ----")
        print("--process 2 ==%d"% g_num)
    
result:
    --process 1--
    --process 2 ==101
    ---process 2 ----
    --process 2 ==100
    
-----------------------
1.7进程内容互不影响
进程间通信 ：
            管道和消息队列 同一台电脑
            网络         不同台电脑

多次fork的问题
# 父进程
    ret = os.fork()
    ret = os.fork()
    ret = os.fork()
并列子进程 2^n = 2^3 = 8

e.g:
    # 父进程
    ret = os.fork()
    if ret == 0:
        print("1)    #子进程
    else:
        print("2")  #父进程
    
    # 父子进程
    ret = os.fork()
    if ret == 0:
        print("11")
    else:
        print("22")
result:
    2
    22
    11    
    1
    22
    11
一共4个进程

e.g:
    ret = os.fork()
    if ret == 0:
        print("1)
    else:
        print("2")
        ret = os.fork()
        if ret == 0:
            print("11")
        else:
            print("22")
result:
    2
    22
    11
    1
一共三个进程

----------------------------------------------
2. multiprocessing模块     Windows环境下使用！！！

-----------------------
2.1 提供了一个process类代表一个进程对象

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，
用start()方法启动，这样创建进程比fork()还要简单。
join()方法等待子进程结束后，在继续下运行，通常用于进程间的同步

2.1.1 Process语法结构如下：
Process([group [,target [,name [,args [,kwargs]]]]])
group:  大多数情况下用不到
target: 表示这个进程实例所调用的对象
name:   未当前进程实例的别名
args:   表示调用对象的位置参数元组
kwargs: 表示调用对象的关键字参数字典

2.1.2 Process类常用方法：
is_alive():         判断进程实例是否还在执行；
join([timeout]):    是否等待进程实例执行结束，或者等待多少秒
start():            启动进程实例（创建子进程）
run():  如果没有给定target参数，对这个对象调用start()方法时，
        就将执行对象中的run()方法
terminate():    不管任务是否完成，立即终止。

2.1.3 Process类常用属性：
name:   当前进程实例别名，默认Process-N ，N从1开始递增
pid:    当前进程实例的PID值。(python id)


-----------------------
2.2进程的创建 -Process 子类
继承Process类
创建新的进程还能使用类的方式，可以自定义一个类，继承Process类，
每次实例化这个类的时候，就等同于实例化一个进程对象。


----------------------------------------------
3. 进程池 Pool

-----------------------
3.1 当需要创建的子进程数量不多时，
可以直接利用multiprocessing中的Process动态生成多个进程，
但是如果是上百个甚至上千个目标，手动的去创建进程工作量巨大，
此时就可以用multiprocessing模块提供的Pool方法。

-----------------------
3.2初始化Pool时，可以指定一个最大进程数，
当有新的请求提交到Pool中时，
如果池还没有满，那么就会创建一个新的进程用来执行该请求；
但如果池中的进程数已经达到指定最大值，那么该请求就会等待，
直到池中有进程结束，才会创建新的进程来执行

-----------------------
3.3 比较
apply():
apply是阻塞的。首先主进程开始运行，碰到子进程，操作系统切换到子进程，
等待子进程运行结束后，在切换到另外一个子进程，直到所有子进程运行完毕。
然后在切换到主进程，运行剩余的部分。
这样跟单进程串行执行没什么区别，子进程是顺序执行的，且子进程全部执行完毕后才继续执行主进程。
apply_async():         # 建议使用此进程池方式创建实例
apply_async 是异步非阻塞的。
即不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。
首先主进程开始运行，碰到子进程后，主进程仍可以先运行，
等到操作系统进行进程切换的时候，在交给子进程运行。
可以做到不等待子进程执行完毕，主进程就已经执行完毕，并退出程序。

-----------------------
此进程池作为主要创建进程的方式
-----------------------

--------------------------------------------
4进程间通信-Queue

-----------------------
4.1 Queue的使用
可以使用multiprocessing模块的Queue实现多进程之间的数据传递，
Queue本身是一个消息队列程序，

》》队列:先进先出       栈:先进后出

说明:
初始化Queue()对象时(q=Queue)
若括号中没有指定最大可接受的消息数量或者数量为负值，
那么就代表可接受的消息数量没有上限（直到内存的尽头）
Queue.qsize():返回当前队列包含的消息数量。
Queue.empty():如果队列为空，返回True
Queue.full() :如果队列满了，返回True

Queue.get([block [, timeout]]):获取队列中的一条消息，然后将其从队列移除，block默认值为True。
    1)如果block使用默认值，且没有设置timeout(),消息队列如果为空，
      此时程序将被阻塞(停在读取状态),直到从消息队列读到消息为止。
      如果设置了timeout，则会等待timeout秒，若还没有读取到任何消息，
      则抛出“Queue.Empty”异常。
    2)如果block值为False,消息队列如果为空，则会立刻抛出“Queue.Empty”异常。
Queue.get_nowait(): 相当于Queue.get(False)

Queue.put(item,[block [, timeout]]):将item消息写入队列，block默认值为True
    1)如果block使用默认值，且没有设置timeout(),消息队列如果已经没有空间可写入，
      此时程序将被阻塞(停在写入状态),直到从消息队列腾出空间为止。
      如果设置了timeout，则会等待timeout秒，若还没有空间，
      则抛出“Queue.Full”异常。
    2)如果block值为False,消息队列如果没有空间写入，则会立刻抛出“Queue.Full”异常。
Queue.put_nowait(item): 相当于Queue.put(item,False)  

-----------------------
4.2 进程池中的Queue
如果要是有Pool创建进程，就要使用multiprocess.manager()的Queue（）。
而不是multiprocess.Queue(),否则会得到错误消息。

-----------------------


------------------------------------------

-------------------------------------------------------
>>>>   重要
-------------------------------------------------------

2.Process 创建进程
2.1例程 进程

# 1.系统库
import sys
import os
import time
import random

#2.第三方库
from multiprocessing import Process
from multiprocessing import Pool
from multiprocessing import Queue

-----------------------------

单进程 示例

# 任务1
def test():
    while True:
        print("--- test function ---")
        time.sleep(1)
        
if __name__ == "__main__":
    pool = Process(target=test)     # 实例对象
    pool.start()                    # 让这个进程开始执行
                                    # test函数里的代码
    # 主进程
    while True:
        print("---main---")
        time.sleep(1)

-----------------------------
多进程

def Function_Test_A():
    print("-A1")
    while True:
        print("-Function_Test_A---")
        print("-A2")
        time.sleep(1)
        print("-A3")

def Function_Test_B():
    print("--B1")
    while True:
        print("--Function_Test_B---")
        print("--B2")
        time.sleep(2)
        print("--B3")

def Function_Test_C():
    print("---C1")
    while True:
        print("---Function_Test_C---")
        print("---C2")
        time.sleep(4)
        print("---C3")


if __name__ == "__main__":

    pool_A = Process(target=Function_Test_A)
    pool_A.start()  # 让这个进程开始执行实例函数里的代码
    pool_B = Process(target=Function_Test_B)
    pool_B.start()  # 让这个进程开始执行实例函数里的代码
    pool_C = Process(target=Function_Test_C)
    pool_C.start()  # 让这个进程开始执行实例函数里的代码

    var = 1000
    print("M1")
    # 主进程
    while True:
        print("Main=============")
        print("M2")
        print(var)
        var += 1
        print("M3")
        time.sleep(0.5)
        print("M4")

说明：
主进程等待Process子进程先结束，即主进程最后结束.(注释主进程，可以体现此现象)

-------------------------

等待join() 等待超时时间

def Function_Test_D():
    print("----D1")
    print("----Function_Test_D----")
    print("----D2")
    for i in range(random.randint(1, 5)):
        print("----D = [%d]" % i)
        print("----D3")
        time.sleep(0.1)
        print("----D4")
    print("----D5")

if __name__ == "__main__":
    pool_D = Process(target=Function_Test_D)
    pool_D.start()  # 让这个进程开始执行实例函数里的代码
    pool_D.join()   # 等待此对象实例子进程结束为止

    print("main")

说明：pool.join() #堵塞 子进程结束后才能执行 print("main")
-------------------------

继承Process类 创建进程

class Process_Class(Process):
    # 因为Process类本身也有__init__方法，这个子类相当于重新写了这个方法。
    # 但是这样带来新的问题，我们并没有完全的初始化一个Process类，
    # 所有就不建议使用。
    # 最好的方法就是将继承本身传递给Process.__init__方法，
    # 完成这些初始化。

    def __init__(self, interval):
        Process.__init__(self)
        self.interval = interval

    # 重新写了Process类的方法run()方法
    def run(self):
        print("子进程(%s)开始执行，父进程(%s)" % (os.getpid(), os.getppid()))
        t_start = time.time()
        time.sleep(self.interval)
        t_stop = time.time()
        print("(%s)执行结束，耗时%0.2f秒" % (os.getpid(), (t_stop - t_start)))

if __name__ == "__main__":
    t_start = time.time()
    print("当前程序进程(%s)" % (os.getpid()))
    pool_E = Process_Class(2)
    # target: 表示这个进程实例所调用的对象
    # start():            启动进程实例（创建子进程）
    # run():  如果没有给定target参数，对这个对象调用start()方法时，
    #         就将执行对象中的run()方法
    # terminate():    不管任务是否完成，立即终止。

    #对一个不包含target属性的Process类执行start()就会运行这个类中run()
    #
    pool_E.start()
    pool_E.join()
    t_stop = time.time()
    print("(%s)执行结束，耗时%0.2f秒" % (os.getpid(), (t_stop - t_start)))

result：
当前程序进程(24264)
子进程(24296)开始执行，父进程(24264)
(24296)执行结束，耗时2.00秒
(24264)执行结束，耗时2.23秒

说明：类对象创建进程，基于上述创建，只是时间不同。
    interval = 2s 间隔时间 2秒

-------------------------

进程池

# 进程池任务
def Function_Test_F(num):
    # random.random()随机生成0-1之间的浮点数
    for i in range(2):
        print("===pid=%d==num=%d="%(os.getpid(), num))
        time.sleep(1)

if __name__ == "__main__":
    # 定义一个进程池，最大进程数
    # 3表示:进程池中最多有3个进程一起执行
    pool_name = Pool(3)

    for i in range(5):
        print("---%d---"%i)
        #向进程池中添加任务
        #注意：如果添加的任务数量,超过了进程池中进程的最大个数的话，
        #     那么不会导致添加不进入,添加到进程中的任务.
        #     如果还没有被执行的话，那么此时他们会等待进程池中的,
        #     进程完成一个任务之后，会自动的去用刚刚的那个进程,
        #     完成当前的新任务
        #pool_F.apply_async(要调用的目标，(传递给目标的参数()元组,))
        pool_name.apply_async(Function_Test_F, (i,))

    # 关闭进程池，相当于不能够再次添加新任务了,pool_F不再接收新的请求
    pool_name.close()
    #等待pool_F中所有子进程执行完成，必须放在close语句之后
    pool_name.join()
    # 主进程　创建／添加　任务后，主进程默认不会等待进程池中的任务执行完后才结束
    # 而是当主进程的任务做完之后　立马结束，
    # 如果这个地方没join,会导致进程池中的任务不会执行

result:
---0---
---1---
---2---
---3---
---4---
===pid=25644==num=0=
===pid=26392==num=1=
===pid=25992==num=2=
===pid=25644==num=0=
===pid=26392==num=1=
===pid=25992==num=2=
===pid=25644==num=3=
===pid=26392==num=4=
===pid=25644==num=3=
===pid=26392==num=4=

说明：可以做创建进程标准模式
规定一定数量进程后，不再考虑进程堵塞问题

此进程池作为主要创建进程的方式

-------------------------

进程间通信

if __name__ == "__main__":
    # 初始化一个Queue对象，最多可接受三条put消息
    queue = Queue(3)
    queue.put("message 1 ")
    queue.put("message 2 ")
    print(queue.full())    # False
    queue.put("message 3 ")
    print(queue.full())    # True
    
    # 因为消息队列已满，下面的try都会抛出异常，
    # 第一个等待2秒再抛出异常
    # 第二个等待4秒再抛出异常
    try:
        queue.put("message 4 ",True,2)
    except Exception:
        print("message full,current number: [%s]" % (queue.qsize()))
    
    try:
        queue.put("message 5 ",True,2)
    except Exception:
        print("message full,current number: [%s]" % (queue.qsize()))
    
    # 推荐的方式，先判断消息队列是否已满，在写入
    if not queue.full():
        queue.put("message 6 ")
    
    # 读取消息时，先判断消息队列是否为空，在读取
    if not queue.empty():
        for var in range(queue.qsize()):
            print(queue.get_nowait())

result：
    False
    True
    message full,current number: [3]
    message full,current number: [3]
    message 1 
    message 2 
    message 3 

-------------------------

Queue 进程间通信 读写数据

# 写数据进程执行的代码
def Function_Write(queue_name_data):
    local_var_queue_data = queue_name_data
    for value in ["A", "B", "C", "D"]:
        print("put [%s] to queue " % (value))
        local_var_queue_data.put(value)
        time.sleep(random.random())

# 读取数据进程执行的代码：
def Function_Read(queue_name_data):
    local_var_queue_data = queue_name_data
    while True:
        if not local_var_queue_data.empty():
            value = local_var_queue_data.get(True)
            print("get [%s] from queue " % (value))
            time.sleep(random.random())
        else:
            break
            
if __name__ == "__main__":

    # 父进程创建Queue，并传给各个子进程: 实例 Queue读写数据
    queue_name = Queue()
    proc_write = Process(target = Function_Write, args = (queue_name,))
    proc_read = Process(target = Function_Read,  args = (queue_name,))

    proc_write.start()  # 启动子进程pw,写入
    proc_write.join()   # 等待pw结束
    proc_read.start()  # 启动子进程pr,写入
    proc_read.join()   # 等待pr结束

    # pr进程是死循环，无法等待其结束，只能强行终止
    print("...")
    print("所有数据都写入并且读完")
    
result：
    put [A] to queue 
    put [B] to queue 
    put [C] to queue 
    put [D] to queue 
    get [A] from queue 
    get [B] from queue 
    get [C] from queue 
    get [D] from queue 
    ...
    所有数据都写入并且读完

-------------------------
# 进程池中通信
def Function_reader(queue_name_data):
    local_var_queue_data = queue_name_data
    print(" reader 启动(%s),父进程为(%s)" % (os.getpid(),os.getppid()))
    for i in range(local_var_queue_data.qsize()):
        print(" Function_reader 从Queue获取到消息: %s " % (local_var_queue_data.get(True)))


def Function_writer(queue_name_data):
    local_var_queue_data = queue_name_data
    print(" writer 启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for var in "dongGe":
        local_var_queue_data.put(var)

if __name__ == "__main__":
    # 进程池中Queue 通信
    print("(%s) start" % (os.getpid()))
    queue_name = Manager().Queue() # 使用Manager中的Queue来初始化
    pool_name = Pool()
    # 使用阻塞模式创建进程，这样就不需要再reader中使用死循环
    pool_name.apply(Function_writer,(queue_name,))
    pool_name.apply(Function_reader,(queue_name,))
    pool_name.close()
    pool_name.join()
    print("(%s) end" % (os.getpid()))

result:
     (36900) start
     writer 启动(37760),父进程为(36900)
     reader 启动(37020),父进程为(36900)
     Function_reader 从Queue获取到消息: d 
     Function_reader 从Queue获取到消息: o 
     Function_reader 从Queue获取到消息: n 
     Function_reader 从Queue获取到消息: g 
     Function_reader 从Queue获取到消息: G 
     Function_reader 从Queue获取到消息: e 
     (36900) end

-------------------------

======================================================

线程

1.如果多个线程执行的都是同一个函数的话，
各自之间互不影响，各自执行





======================================================
'''


'''
# ============================================================================
# Function:  
# Explain :  输入参数   
#         :  输出参数  
# ============================================================================
'''

#-------------------------
# 单进程任务
def Function_Test_A():
    print("-A1")
    while True:
        print("-Function_Test_A---")
        print("-A2")
        time.sleep(1)
        print("-A3")

#-------------------------
# 多进程任务
def Function_Test_B():
    print("--B1")
    while True:
        print("--Function_Test_B---")
        print("--B2")
        time.sleep(2)
        print("--B3")

#-------------------------
# 多进程任务
def Function_Test_C():
    print("---C1")
    while True:
        print("---Function_Test_C---")
        print("---C2")
        time.sleep(4)
        print("---C3")

#-------------------------
# 多进程任务，join()
def Function_Test_D():
    print("----D1")
    print("----Function_Test_D----")
    print("----D2")
    for i in range(random.randint(1, 5)):
        print("----D = [%d]" % i)
        print("----D3")
        time.sleep(0.1)
        print("----D4")
    print("----D5")

#-------------------------
# 继承Process类 新建进程
class Process_Class(Process):
    # 因为Process类本身也有__init__方法，这个子类相当于重新写了这个方法。
    # 但是这样带来新的问题，我们并没有完全的初始化一个Process类，
    # 所有就不建议使用。
    # 最好的方法就是将继承本身传递给Process.__init__方法，
    # 完成这些初始化。

    def __init__(self, interval):
        Process.__init__(self)
        self.interval = interval

    # 重新写了Process类的方法run()方法
    # start()调用run()方法
    def run(self):
        print("子进程(%s)开始执行，父进程(%s)" % (os.getpid(), os.getppid()))
        t_start = time.time()
        time.sleep(self.interval)
        t_stop = time.time()
        print("(%s)执行结束，耗时%0.2f秒" % (os.getpid(), (t_stop - t_start)))

#-------------------------
# 进程池任务
def Function_Test_F(num):
    # random.random()随机生成0-1之间的浮点数
    for i in range(2):
        print("===pid=%d==num=%d="%(os.getpid(), num))
        time.sleep(1)

#-------------------------
# 写数据进程执行的代码
def Function_Write(queue_name_data):
    local_var_queue_data = queue_name_data
    for value in ["A", "B", "C", "D"]:
        print("put [%s] to queue " % (value))
        local_var_queue_data.put(value)
        time.sleep(random.random())

# 读取数据进程执行的代码：
def Function_Read(queue_name_data):
    local_var_queue_data = queue_name_data
    while True:
        if not local_var_queue_data.empty():
            value = local_var_queue_data.get(True)
            print("get [%s] from queue " % (value))
            time.sleep(random.random())
        else:
            break
#-------------------------
# 进程池中通信
def Function_reader(queue_name_data):
    local_var_queue_data = queue_name_data
    print(" reader 启动(%s),父进程为(%s)" % (os.getpid(),os.getppid()))
    for i in range(local_var_queue_data.qsize()):
        print(" Function_reader 从Queue获取到消息: %s " % (local_var_queue_data.get(True)))


def Function_writer(queue_name_data):
    local_var_queue_data = queue_name_data
    print(" writer 启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for var in "dongGe":
        local_var_queue_data.put(var)


#-------------------------

# ============================================================================
'''
# ============================================================================
#   测试专用
# ============================================================================
'''
if __name__ == "__main__":

    # #-------------------------
    # # 单/多进程
    # pool_A = Process(target=Function_Test_A)
    # pool_A.start()  # 让这个进程开始执行实例函数里的代码
    # pool_B = Process(target=Function_Test_B)
    # pool_B.start()  # 让这个进程开始执行实例函数里的代码
    # pool_C = Process(target=Function_Test_C)
    # pool_C.start()  # 让这个进程开始执行实例函数里的代码
    # var = 1000
    # print("M1")
    # while True:
    #     print("Main=============")
    #     print("M2")
    #     print(var)
    #     var += 1
    #     print("M3")
    #     time.sleep(0.5)
    #     print("M4")


    # #-------------------------
    # #添加join()
    # pool_D = Process(target=Function_Test_D)
    # pool_D.start()  # 让这个进程开始执行实例函数里的代码
    # pool_D.join()   # 等待此对象实例子进程结束为止
    # print("main")


    # #-------------------------
    # #继承Process类 新建进程
    # t_start = time.time()
    # print("当前程序进程(%s)" % (os.getpid()))
    # # interval = 2s 间隔时间 2秒
    # pool_E = Process_Class(2)
    # # target :  表示这个进程实例所调用的对象
    # # start(): 启动进程实例（创建子进程）
    # # run()  :   如果没有给定target参数，对这个对象调用start()方法时，
    # #          就将执行对象中的run()方法
    # # terminate(): 不管任务是否完成，立即终止。
    # # 对一个不包含target属性的Process类执行start()就会运行这个类中run()
    # pool_E.start() # start()调用run()方法
    # pool_E.join()
    # t_stop = time.time()
    # print("(%s)执行结束，耗时%0.2f秒" % (os.getpid(), (t_stop - t_start)))


    # #-------------------------
    # # 进程池
    # # 定义一个进程池，最大进程数
    # # 3表示:进程池中最多有3个进程一起执行
    # pool_name = Pool(3)
    #
    # for i in range(5):
    #     print("---%d---"%i)
    #     #向进程池中添加任务
    #     #注意：如果添加的任务数量,超过了进程池中进程的最大个数的话，
    #     #     那么不会导致添加不进入,添加到进程中的任务.
    #     #     如果还没有被执行的话，那么此时他们会等待进程池中的,
    #     #     进程完成一个任务之后，会自动的去用刚刚的那个进程,
    #     #     完成当前的新任务
    #     #pool_F.apply_async(要调用的目标，(传递给目标的参数()元组,))
    #     pool_name.apply_async(Function_Test_F, (i,))
    #
    # # 关闭进程池，相当于不能够再次添加新任务了,pool_F不再接收新的请求
    # pool_name.close()
    # #等待pool_F中所有子进程执行完成，必须放在close语句之后
    # pool_name.join()
    # # 主进程　创建／添加　任务后，主进程默认不会等待进程池中的任务执行完后才结束
    # # 而是当主进程的任务做完之后　立马结束，
    # # 如果这个地方没join,会导致进程池中的任务不会执行



    # # #-------------------------
    # # 初始化一个Queue对象，最多可接受三条put消息
    # queue = Queue(4)
    # queue.put("message 1 ")
    # queue.put("message 2 ")
    # print(queue.full())    # False
    # queue.put("message 3 ")
    # print(queue.full())    # True
    #
    # # 因为消息队列已满，下面的try都会抛出异常，
    # # 第一个等待2秒再抛出异常
    # # 第二个等待4秒再抛出异常
    # try:
    #     queue.put("message 4 ",True,2)
    # except Exception:
    #     print("message full,current number: [%s]" % (queue.qsize()))
    #
    # try:
    #     queue.put("message 5 ",True,2)
    # except Exception:
    #     print("message full,current number: [%s]" % (queue.qsize()))
    #
    # # 推荐的方式，先判断消息队列是否已满，在写入
    # if not queue.full():
    #     queue.put("message 6 ")
    #
    # # 读取消息时，先判断消息队列是否为空，在读取
    # if not queue.empty():
    #     print(queue.qsize())
    #     for var in range(queue.qsize()):
    #         print(queue.get_nowait())
    #


    # # #-------------------------
    # # 父进程创建Queue，并传给各个子进程: 实例 Queue读写数据
    # queue_name = Queue()
    # proc_write = Process(target = Function_Write, args = (queue_name,))
    # proc_read = Process(target = Function_Read,  args = (queue_name,))
    #
    # proc_write.start()  # 启动子进程pw,写入
    # proc_write.join()   # 等待pw结束
    # proc_read.start()  # 启动子进程pr,写入
    # proc_read.join()   # 等待pr结束
    #
    # # pr进程是死循环，无法等待其结束，只能强行终止
    # print("...")
    # print("所有数据都写入并且读完")


    # # #-------------------------
    # # 进程池中Queue 通信
    # print("(%s) start" % (os.getpid()))
    # queue_name = Manager().Queue() # 使用Manager中的Queue来初始化
    # pool_name = Pool()
    # # 使用阻塞模式创建进程，这样就不需要再reader中使用死循环
    # pool_name.apply(Function_writer,(queue_name,))
    # pool_name.apply(Function_reader,(queue_name,))
    # pool_name.close()
    # pool_name.join()
    # print("(%s) end" % (os.getpid()))


    print(" learn finish")


    

--

 finish

--------