python多进程

#1、基本创建
import multiprocessing as mp
import threading as td

def job(a, b):
    print(a, b)

def main():
    p1 = mp.Process(target=job, args=(1, 2))  # 必须在主函数写，调用启动一个子进程
    p1.start()  #子进程开始运行
    p1.join()   #等待子进程运行之后，主进程才往下运行

if __name__ == '__main__':
    main()

#2、队列基本使用
import multiprocessing as mp
import threading as td

def job(q):
    res = 0
    for i in range(1000):
        res += i + i ** 2 + i ** 3
        q.put(res)

def main():
    q = mp.Queue()
    p1 = mp.Process(target=job, args=(q,))
    p2 = mp.Process(target=job, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get()
    res2 = q.get()
    print('执行完成', res1, res2)

    if __name__ == '__main__':
        main()

#3、 不用线程进程、用多线程、用多进程对比
import multiprocessing as mp
import threading as td
import time

# 工作函数
def job(q):
    res = 0
    for i in range(1000000):
        res += i + i ** 2 + i ** 3
    q.put(res)

# 多进程
def multprocess():
    q = mp.Queue()
    p1 = mp.Process(target=job, args=(q,))
    p2 = mp.Process(target=job, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    res1 = q.get()
    res2 = q.get()
    print('multprocess执行完成', res1 + res2)


# 多线程
def multthread():
    q = mp.Queue()
    t1 = td.Thread(target=job, args=(q,))
    t2 = td.Thread(target=job, args=(q,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    res1 = q.get()
    res2 = q.get()
    print('multthread执行完成', res1 + res2)


# 普通
def normal():
    res = 0
    for i in range(2):  # 与两个线程、两个进程做对比
        for i in range(1000000):
            res += i + i ** 2 + i ** 3
    print('normal执行完成', res)

# 主函数
if __name__ == '__main__':
    st = time.time()
    normal()
    st1 = time.time()
    print('normal耗时:', st1 - st)
    multthread()
    st2 = time.time()
    print('multthread耗时:', st2 - st1)
    multprocess();
    print('multprocess耗时:', time.time() - st2)


#4、pool多进程池
import multiprocessing as mp
import threading as td
import time

# 工作函数
def job(x):
    return x * x

def multipool():  # 进程池
    pool = mp.Pool(processes=3)  # 不传参数默认使用所有的cpu,这样只用3个
    res = pool.map(job, range(10))  # 可以放入多个参数，多个进程去执行
    print(res)
    res = pool.apply_async(job, (2,))  # 1次只能使用一个进程算一个东西，第一个是工作对象,第二个是对象(此处只能有1个参数)
    print(res.get())
    pool_list = [pool.apply_async(job, (i,)) for i in range(10)]  # 迭代，可以多个参数了
    print([data.get() for data in pool_list])

# 主函数
if __name__ == '__main__':
    multipool()

#5、共享内存
import multiprocessing as mp

# 共享内存，多进程多核之间交流，必须用共享内存
value = mp.Value('d', 1)  # 第一个参数代表类型
array = mp.Array('i', [1, 2, 3])  # 第一个参数代表类型,第二个参数只能是一维的一个列表,不能是多维

#6、 共享内存应用、锁
import multiprocessing as mp
import time

def job(lock, v, num):
    lock.acquire()
    for _ in range(10):
        time.sleep(0.1)
        v.value += num  # 多进程之间使用共享内存设置、取值都要用.value才可以
        print(v.value)
    lock.release()


def main():
    lock = mp.Lock()
    v = mp.Value('i', 0);
    t1 = mp.Process(target=job, args=(lock, v, 1));
    t2 = mp.Process(target=job, args=(lock, v, 3));
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(v.value)


if __name__ == '__main__':
    st = time.time()
    main()
    f = time.time() - st
    print(f)