# coding:utf-8
# 導入多進程的包，并重命名為mp
import multiprocessing as mp
# 主要工作
def p1():
    print("zxy")
if __name__ == "__main__":
    # 創(chuàng)建新進程
    new_process = mp.Process(target=p1, name="p1")
    # 啟動這個進程
    new_process.start()
    # 阻塞該進程
    new_process.join()

# coding:utf-8
import time
import multiprocessing as mp
"""
    使用多進程時，運行程序所用的時間
"""
def job1(q):
    res = 0
    for i in range(100):
        res += i + i**5 +i**8
        time.sleep(0.1)
    # 將結(jié)果放入隊列中
    q.put(res)
def job2(q):
    res = 0
    for i in range(100):
        res += i + i**5 +i**8
        time.sleep(0.1)
    q.put(res)
if __name__ == "__main__":
    start_time = time.time()
    # 創(chuàng)建隊列
    q = mp.Queue()
    # 創(chuàng)建進程1
    process1 = mp.Process(target=job1, args=(q,))
    # 創(chuàng)建進程2
    process2 = mp.Process(target=job2, args=(q,))
    process1.start()
    process2.start()
    # 通過隊列獲取值
    res1 = q.get()
    res2 = q.get()
    print("res1為%d,res2為%d" % (res1, res2))
    end_time = time.time()
    print("整個過程所用時間為%s" %(end_time-start_time))

# coding:utf-8
import multiprocessing as mp
import time
import threading as th
"""
    多進程、多線程、普通方法的性能比較
"""
# 多進程工作
def mp_job(res):
    for i in range(10000000):
        res += i**5 + i**6
    print(res)
# 多線程工作
def mt_job(res):
    for i in range(10000000):
        res += i**5 + i**6
    print(res)
# 普通方法工作
def normal_job(res):
    for i in range(10000000):
        res += i ** 5 + i ** 6
    print(res)
if __name__ == "__main__":
    mp_sum = 0
    mp_start = time.time()
    process1 =mp.Process(target=mp_job, args=(mp_sum, ))
    process2 = mp.Process(target=mp_job, args=(mp_sum,))
    process1.start()
    process2.start()
    process1.join()
    process2.join()
    mp_end = time.time()
    print("多進程使用時間為", (mp_end-mp_start))
    mt_start = time.time()
    mt_sum = 0
    thread1 = th.Thread(target=mt_job, args=(mt_sum, ))
    thread2 = th.Thread(target=mt_job, args=(mt_sum, ))
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
    mt_end = time.time()
    print("多線程使用的時間是", (mt_end-mt_start))
    normal_start = time.time()
    normal_sum = 0
    # 進行兩次
    normal_job(normal_sum)
    normal_job(normal_sum)
    normal_end = time.time()
    print("普通方法使用的時間是", (normal_end-normal_start))

# coding:utf-8
import time
import multiprocessing as mp
"""
    進程池pool的使用
"""
def job(num):
    time.sleep(1)
    return num * num
if __name__ == "__main__":
    start_time = time.time()
    # 括號里面不加參數(shù)時，默認使用進程池中所有進程
    pool = mp.Pool()
    res = pool.map(job, range(10))
    print(res)
    end_time = time.time()
    print("運行時間為", (end_time-start_time))

# coding:utf-8
import time
import multiprocessing as mp
"""
    進程池pool的使用
"""
def job(num):
    time.sleep(1)
    return num * num
if __name__ == "__main__":
    start_time = time.time()
    # 括號里面加參數(shù)時，指定兩個進程進行處理
    pool = mp.Pool(processes=2)
    res = pool.map(job, range(10))
    print(res)
    end_time = time.time()
    print("運行時間為", (end_time-start_time))

# coding:utf-8
import time
def job(res):
    for i in range(10):
        res.append(i*i)
        time.sleep(1)
if __name__ == "__main__":
    start_time = time.time()
    res = []
    job(res)
    print(res)
    end_time =time.time()
    print("不使用進程池所用時間為", (end_time-start_time))

# coding:utf-8
import multiprocessing as mp
"""
    共享內(nèi)存
"""
if __name__ == "__main__":
    # 第一個參數(shù)是數(shù)據(jù)類型的代碼，i代表整數(shù)類型
    # 第二個參數(shù)是共享數(shù)據(jù)的值
    v = mp.Value("i", 0)

# coding:utf-8
import multiprocessing as mp
import time
"""
    進程中的鎖lock
"""
def job(v, num):
    for i in range(10):
        v.value += num
        print(v.value)
        time.sleep(0.2)
if __name__ == "__main__":
    # 多進程中的共享內(nèi)存
    v = mp.Value("i", 0)
    # 進程1讓共享變量每次加1
    process1 = mp.Process(target=job, args=(v, 1))
    # 進程2讓共享變量每次加3
    process2 = mp.Process(target=job, args=(v, 3))
    process1.start()
    process2.start()

# coding:utf-8
import multiprocessing as mp
import time
"""
    進程中的鎖lock
"""
def job(v, num, l):
    # 加鎖
    l.acquire()
    for i in range(10):
        v.value += num
        print(v.value)
        time.sleep(0.2)
    # 解鎖
    l.release()
if __name__ == "__main__":
    # 創(chuàng)建進程鎖
    l = mp.Lock()
    # 多進程中的共享內(nèi)存
    v = mp.Value("i", 0)
    process1 = mp.Process(target=job, args=(v, 1, l))
    process2 = mp.Process(target=job, args=(v, 3, l))
    process1.start()
    process2.start()