python多进程、python多线程、numba 加速

python多进程、python多线程、numba 加速

---

---

前言

以下内容是我为了解决一个for循环遍历速度太慢问题所看的一些内容总结了以下。虽然这个并没有解决我的问题，，，

---

1、for循环遍历使用numba 加速

导入包，没有包，pip安装numba

from numba import jit     #使用jit 模块   pip install numba or conda install numba

在for循环函数上一行这个

#使用装饰器，jit 加速
@jit         # 就是这么一个简单的改变

程序

import cv2
import time
from numba import jit     #使用jit 模块   pip install numba or conda install numba

path = "..."
path1 = "..."
#-------------------------------3--------#
#使用装饰器，jit 加速
@jit         # 就是这么一个简单的改变
def processImg_jit(img):
    for i in range(1080):
        for j in range(1920):
            if img[i][j] == 128 
    return img
#----------------------------------------#
# 原始的
def processImg(img_):
    for i in range(1080):
        for j in range(1920):
            if img_[i][j][0] == 128 
    return img
#-----------------------------------3----#
img = cv2.imread("图片地址")  # 读图片 黑白图片
t0 = time.time()
img = processImg(img)
t1 = time.time()
print("原始: ",t1 - t0)

t0 = time.time()
img = processImg_jit(img)
t1 = time.time()
print("加速:",t1 - t0)

2、python多进程

multiprocessing模块

这里我是使用multiprocessing模块: 创建Process的实例，传入任务执行函数作为参数。
几个用到的函数功能：

函数	功能
apply_async()	异步执行（并行）
apply()	同步执行（串行）
terminate()	立刻关闭进程池
join()	主进程等待所有子进程执行完毕。必须在close或terminate()之后使用
close()	等待所有进程结束后，才关闭进程池

import time
import multiprocessing
import os

# os.getpid() 获取子进程id
# os.getppid() 获取子进程的父进程id
# multiprocessing.current_process() 获取进程名字
# my_dance = multiprocessing.Process(target=dance,name='进程名字')
import multiprocessing

def hello(a,b):
    for i in range(5):
        print("hello",i)
    a+=b
    print(a)

def didi(a,b):
    for i in range(5):
        print(a,b)

if __name__ == '__main__':
    # 默认：主进程会等待子进程结束之后，再结束！！！
    # 程序一旦执行，就默认创建主进程。

    # 带有参数的函数
    # args:元组(单个元素的元组有 , 号)
    my_hello = multiprocessing.Process(target=hello,args=(5,6))

    # kwargs：字典的形式(key值要和函数中的形参完全一致)
    # 注意这里字典的key值必须是字符串类型（不可变类型！！）
    my_didi = multiprocessing.Process(target=didi,kwargs={"a":1,"b":2})
    
    # 守护主进程(进程)，注意：这个设置必须start()方法之前设置。
    # my_func.daemon = True
    my_hello.start() # 开启进程
    my_didi.start()
    # 手动设置,terminate()方法结束子进程。
    #my_dance.terminate()
    exit()  # 参数0：无错误退出，参数1：有错误退出

使用进程池Pool

import multiprocessing
import time

def func(msg):

    time.sleep(2)  # 延时2s
    print("msg:", msg)

if __name__ == "__main__":
    # 维持执行的进程总数为processes，当一个进程开启后会添加新的进程进去
    # 5条进程并行
    pool = multiprocessing.Pool(processes=5)
    
    for i in range(5):
        msg = "hello %d" % (i)
        # 非阻塞式，子进程不影响主进程的执行，会直接运行到 pool.join()
        # apply() 串行
        pool.apply_async(func, (msg,))  # 并行

        # 阻塞式，先执行完子进程，再执行主进程
        # pool.apply(func, (msg, ))

    print("开始")
    # 调用join之前，先调用close函数，否则会出错。
    pool.close()
    # 执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
    pool.join()
    print("结束")

派生Process的子类

使用multiprocessing模块: 派生Process的子类，重写run方法

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self, name):
        super(MyProcess, self).__init__()
        self.name = name
    def run(self):
        print('process name :' + str(self.name))
        time.sleep(1)
if __name__ == '__main__':
    for i in range(3):
        p = MyProcess(i)
        p.start()
    for i in range(3):
        p.join()

3、多线程

多线程跟多进程类似，这里就不过多说了。

# 1. 导包
import threading
import time

def hello():
    for i in range(5):
        print("hello",i)
        time.sleep(1)

def hi():
    for i in range(5):
        print("hi",i)
        time.sleep(1)

if __name__ == '__main__':
    # 2.创建子线程
    hello = threading.Thread(target=hello)
    hi = threading.Thread(target=hi)

    # 3. 开启子线程
    hello.start()
    hi.start()

---

如何选择：
如果程序是属于CPU密集型，建议使用多进程。而多线程就更适合应用于I/O密集型程序。

名称	功能
CPU 密集型	程序比较偏重于计算，需要经常使用CPU来运算
I/O 密集型	程序需要频繁进行输入输出操作

总结

未完待续，，，，