进程池

# import os
# print(os.cpu_count())
# # 多线程最佳数量：os.cpu_count()*5
#
# # 进程池：一个池子，里面有固定数量的进程，这些进程一直属于待命状态，一旦有任务，马上就有进程去处理
#
# from multiprocessing import  Pool
# p=Pool(os.cpu_count()+1)

# 多进程和进程池的效率对比
# from multiprocessing import Pool,Process
# import os
# import time
# import requests
# # def func(num):
# #
# #     num+=1
# #     print(num)
#
# def func(url):
#     res = requests.get(url)
#     if res.status_code ==200:
#         return 'ok'
#
# if __name__ == '__main__':
#     # p = Pool(os.cpu_count()+1)
    # start = time.time()
    # ret = map(func,[i for i in range(100)])
    # print('主进程map的返回值',ret)
    # p.close()
    # p.join()
    # print('进程池做任务的效率',time.time()-start)


    # 开1001个进程
    # p_l = []
    # start2 = time.time()
    # for i in range(100):
    #     p1 = Process(target=func,args=(i,))
    #     p1.start()
    #     p_l.append(p1)
    # [p1.join() for p1 in p_l]
    # print('多进程直接做任务的效率：',time.time()-start2)

    #
    # p = Pool(5)
    # start = time.time()
    # for i in range(1000):
    #     p.apply_async(func,args=(i,)) #异步
    #     # p.apply(func,args=(i,)) #同步
    #
    # p.close()
    # p.join()
    # print(time.time() - start)


    # start = time.time()
    # lst = []
    # for i in range(1000):
    #     res = p.apply_async(func,args=(i,))
    #     lst.append(res)
    # p.close()
    # p.join()
    # print('我是异步',time.time()-start)
    # [print(i.get()) for i in lst]


    # headers = {''}
    # # p = Pool(5)
    # lst =[
    #     'https://www.baidu.com',
    #     'https://www.jd.com',
    #     'https://www.taobao.com',
    #     'https://www.mi.com',
    #     'https://cnblog.com',
    #     'https://www.bilibli.com'
    # ]
    # start = time.time()
    # for i in lst:
    #     p.apply(func,args=(i,))
    # print('同步时间是：',time.time()-start)
    #
    # start2 = time.time()
    # for i in lst:
    #     p.apply_async(func,args=(i,))
    # p.close()
    # p.join()
    # print('异步时间：',time.time()-start2)

#
# from threading import Thread
# # def func(a):
# #     print(a)
# #     print('这是一个子线程')
# #
# # if __name__ == '__main__':
# #     t=Thread(target=func,args=(1,))
# #     t.start()
#
#
# class MyT(Thread):
#     def __init__(self):
#         super().__init__()
#
#     def run(self):
#         print('我是一个子进程')
#
# t =MyT()
# t.start()

from multiprocessing import Process
from threading import Thread
import time
import os
# 对比一
# def func():
#     pass
# if __name__ == '__main__':
#     start = time.time()
#     for i in range(100):
#         p = Process(target=func)
#         p.start()
#     print('开100个进程的时间：',time.time() - start)
#
#     start2 = time.time()
#     for i in range(100):
#         p1  = Thread(target=func)
#         p1.start()
#     print('开100个线程的时间：',time.time()-start2)


# def func(name):
#     print('我是一个%s，我的pid是%s，我父亲的pid是%s'%(name,os.getpid(),os.getppid()))
#
#
# if __name__ == '__main__':
#     print('我是main，我的pid是%s，我父亲的pid是%s'%(os.getpid(),os.getppid()))
#     for i in range(10):
#         p=Process(target=func,args=('线程',))
#         p.start()
#     for i in range(10):
#         t=Thread(target=func,args=('线程',))
#         t.start()


# 对比三
# def func():
#     global num
#     num-=1
#     tmp = num
#     num=tmp-1
#
# if __name__ == '__main__':
#     num = 100
#     t = Thread(target=func)
#     t.start()
#     print(num)

# 计时器
# from threading import Timer
# def func():
#     print('nb')
#
# Timer(2.5,func).start()


# from  threading import Thread
# from multiprocessing import  Process
# import time
#
# def func():
#     time.sleep(2)
#     print(123)
# def func1():
#     time.sleep(3)
#     print('abc')
# if __name__ == '__main__':
#     t = Thread(target=func)
#     t.daemon =True
#     t.start()
#     t1 = Thread(target=func1)
#     print('主进程代码结束')


# 守护进程
# def func():
#     time.sleep(2)
#     print(123)
# def func1():
#     time.sleep(10)
#     print('abc')
# if __name__ == '__main__':
#     p = Process(target=func)
#     p.daemon =True
#     p.start()
#     p1 = Process(target=func1)
#     p1.start()
#     time.sleep(3)
#     print('主代码结束了')

# from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
# from multiprocessing import Pool
# import time
# import os
# def func(num):
#     sum = 0
#     for i in range(num):
#         for j in range(i):
#             for n in range(j):
#                 sum+=n**2
#
# if __name__ == '__main__':
#     p = Pool(5)
#     start = time.time()
#     for i in range(200):
#         p.apply_async(func,args=(i,))
#     p.close()
#     p.join()
#     print('pool进程池的执行效率:',time.time()-start)
#
#
#
#
#     # 进程池2
#     p=ProcessPoolExecutor(5)
#     start = time.time()
#     for i in range(250):
#         p.submit(func,i)
#     p.shutdown()
#     print('ProcessPoolExecutor进程池的执行效率：',time.time()-start)
#
#
#     # 线程池
#     tp = ThreadPoolExecutor(20)
#     start2 = time.time()
#     for i in range(250):
#         tp.submit(func,i)
#     tp.shutdown()
#     print('线程池的消耗的时间为：',time.time() - start2)



# from concurrent.futures import ThreadPoolExecutor
# import time
# def func(num):
#     sum = 0
#     for i in range(num):
#         sum+=i
#     return sum
# t = ThreadPoolExecutor(20)
#
# lst =[]
# for i in range(10):
#     ret = t.submit(func,i)
#     lst.append(ret)
# print(lst)
# for j in lst:
#     print(j.result())

# res = t.map(func,[1,2,3])
# t.shutdown()
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())

from concurrent.futures import ThreadPoolExecutor
from threading import current_thread
import time
def func(num):
    sum = 0
    time.sleep(1)
    for i in range(num):
        sum+=i
    print('这是子线程中',current_thread())
    return sum
def call_back(x):
    time.sleep(1)
    print('这是回调函数中',current_thread())

t = ThreadPoolExecutor(20)
for i in range(10):
    t.submit(func,i).add_done_callback(call_back)
t.shutdown()
print('主线程中',current_thread())