python3的使用

下面分别是python 进一步封装好的线程池和进程池

from concurrent.futures import  ThreadPoolExecutor
from concurrent.futures import  ProcessPoolExecutor

import time

def task(arg):
    print(arg)
    time.sleep(1)
    
pool= ProcessPoolExecutor
pool= ThreadPoolExecutor

for i in range(50):
    pool.submit(task,i)

一、再次了解相同区别

进程：
优点：同时利用多个cpu,能够同时进行多个操作
缺点：耗费资源（因为給开辟内存空间）
线程：
优点：共享内存，io操作的时候，创作并发操作
缺点：抢占资源
进程：不是越多越好，cpu个数等于进程个数
线程：也不是越多越好，具体案例具体分析，请求上下文切换耗时，计算机中执行任务的最小单元是线程

二、目的

进程和线程目的：提高效率
Io操作不利用cpu：
IO密集型（不使用cpu）：多线程----GIL全局解释器锁
计算密集型（使用cpu）：多进程

三、进程

1.创建进程

from multiprocessing import Process

def test(n):
    print(n)

if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()

2.进程中的join等待，等待进程结束运行下一个进程
未使用join运行结果

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()

    print("end")
》》》
end
0
3
1
2

使用join

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':
    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()
        #等待的意思
        p.join()

    print("end")、
》》》
0
1
2
3
end

3.deamon 等同线程中setdeamon线程守护

from multiprocessing import Process
import time
def test(n):
    print(n)
    time.sleep(2)
if __name__ == '__main__':

    for i in range(4):
        p = Process(target=test,args=(i,))
        # 进程守护，结束都结束
        p.daemon = True
        p.start()


    print("end")

四、通过代码理解进程

进程可以理解成是对主进程的copy~，也就是如果线程对一个列表操作的话，实际上是对同一个列表操作，进程操作的就是复制出来的列表

from multiprocessing import Process
import time
a_list = []
def test(n):
    a_list.append(n)
    print(a_list)

if __name__ == '__main__':
    for i in range(4):
        p = Process(target=test,args=(i,))
        p.start()


    print("end")
>>>
end
[0]
[1] 
[3]
[2]

五、进程池

p = Pool(5)
p.apply          每一个任务都是排队进行的，相当于自身包含个join方法
p.apply_async   每一个任务都是并发进行的，可以设置回调函数，deamon=True，等待线程

进程和线程其实还有一点区别，就是如果主线程执行完毕，其实子线程还是在运行的，除非设置了保护线程。单进程不是这样，如果主进程结束了，子进程也不会执行

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)
if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))

上面的代码运行结果没有的，因为主进程结束了，子进程还在sleep等待，主进程销毁了子进程也跟着销毁了
有两种办法解决，方法一主进程的结束时间大于子进程

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)


if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))

    time.sleep(2.5)

第二种使用join进程等待

from multiprocessing import Pool
import time
def f1(a):
    time.sleep(1)
    print(a)


if __name__ == '__main__':
    pool = Pool(5)
    for i in range(10):
        pool.apply_async(func=f1,args=(i,))
    pool.close()
    pool.join()

上面的代码运行的时候五个为一个结果展示

python_多线程/多进程（二）