from  multiprocessing import Process, Pipe

def f1(conn):

    from_zjc_msg = conn.recv()

    print('我是子进程')

    print('来自主进程的消息:', from_zjc_msg)

if __name__ == '__main__':

    conn1, conn2 = Pipe() # 创建一个管道对象, 全双工, 返回管道的两端, 但是一端发送的消息,只能另一端接受;自己这一端无法接收

    # 可以将一端或两端发送给其他的进程, 那么多个进程之间就这一通过这一管道进行通信

    p1 = Process(target=f1, args=(conn2, ))

    p1.start()

    conn1.send('有点困了')

    print('我是主进程')

from multiprocessing import Process, Event

e = Event() # 创建事件对象, 这个对象的初始状态为False

print('e的状态是', e.is_set())

print('程序运行到了这里')

e.set() # 将e的状态改为True

print('e的状态是', e.is_set())

# e.clear() # 将e的状态改为False

e.wait() # e这个事件对象如果值为False, 就在此处等待.

print('程序过了wait')

import time

from multiprocessing import Process, Event

def f1(e):

    time.sleep(2)

    n = 100

    print('子进程计算结果为:', n)

    e.set()

if __name__ == '__main__':

    e = Event()

    p = Process(target=f1, args=(e, ))

    p.start()

    print('主进程等待.....')

    e.wait()

    print('结果已经出来, 可以拿到该值')

import time

import random

from multiprocessing import Process, Semaphore

def f1(i, s):

    s.acquire()

    print('%s号嘉宾进去了' % i)

    time.sleep(random.randint(1, 3))

    print('%s号嘉宾出来了' % i)

    s.release()

if __name__ == '__main__':

    s = Semaphore(2) # 计数器2, acquire 一次减一, 为0, 其他人等待, release加1

    for i in range(5):

        p = Process(target=f1, args=(i, s))

        p.start()

#　#　进程池和多进程执行时间的对比

import time

from multiprocessing import Process, Pool

def f(n):

    for i in range(5):

        n += i

if __name__ == '__main__':

    # 统计进程池执行100个任务的时间

    s_time = time.time()

    pool = Pool(4) # 里面这个参数是指定进程池中有多少个进程, 4表示4个进程, 如果不传参, 默认开启的进程数一般是cpu的个数

    pool.map(f, range(100)) # 参数数据必须是可迭代的, 异步提交任务, 自带join功能

    e_time = time.time()

    dif_time = e_time - s_time

    # 统计100个进程, 来执行100个任务的执行时间

    p_s_t = time.time() # 多进程起始时间

    p_list = [ ]

    for i in range(100):

        p = Process(target=f, args=(i,))

        p.start()

        p_list.append(p)

    [pp.join() for pp in p_list]

    p_e_t = time.time()

    p_dif_t = p_e_t - p_s_t

    print('进程池的执行时间:', dif_time)

    print('多进程的执行时间:', p_dif_t)

import time

from multiprocessing import Process, Pool

def f1(n):

    # print(n)

    time.sleep(2)

    return n * 2

if __name__ == '__main__':

    pool = Pool(2)

    for i in range(5):

        print('xxxxx')

        res = pool.apply(f1, args=(i, ))

        print(res)

import time

from multiprocessing import Process, Pool

def f1(n):

    time.sleep(2)

    return n * 2

if __name__ == '__main__':

    pool = Pool(2)

    res_list = [ ]

    for i in range(5):

        print('xxxxx')

        res = pool.apply_async(f1, args=(i,))

        res_list.append(res)

    for i  in res_list:

        print(i.get())

import os

from multiprocessing import Pool, Process

def f1(n):

    print('进程池里面的进程pid', os.getpid())

    print(n)

    return 2 * n

def f2(n):

    print('回调函数里面的进程pid', os.getpid())

    print(n)

if __name__ == '__main__':

    pool = Pool(4)

    res = pool.apply_async(f1, args=(5,), callback=f2)

    pool.close()

    pool.join()

    print('主程序里面的进程pid', os.getpid())