传递类变量是否会阻止Numba的并行化运行？

算力阿峰

2026-6-25

问题

我有一个包装器方法用于调用Numba兼容函数。下方代码中，get_neighbours_wrapper()方法仅作为包装器调用Numba函数get_neighbours_Numba()。
我希望在独立线程中调用neighbours.get_neighbours_wrapper(point)以实现并行化。虽然改成Numba兼容函数后性能有提升，但我不确定它是否真的在并行运行（大概率没有）。我怀疑调用get_neighbours_wrapper()时访问类成员变量可能会阻止真正的并行化（是不是因为GIL锁？）。

import numpy as np
from numba import njit

@njit
def get_neighbours_Numba(points: np.ndarray, num_neighbors: int):

    for point in points:
        distances = np.zeros(num_neighbors)
        neighbours_indices_xy = np.zeros((num_neighbors, 2))
        
        ## 此处有其他代码，但与问题无关
    
    return  distances


class Neighbours:
    def __init__(self, xy_points: np.ndarray, num_neighbors: int):
        self.xy_points = xy_points
        self.num_neighbors = num_neighbors

    def get_neighbours_wrapper(self, point: np.ndarray):
        distances = get_neighbours_Numba(self.xy_points, self.num_neighbors)   # 问题：使用类变量是否会阻止并行化？
        return distances
    

# 示例用法
xy_points = np.random.rand(100, 2)
num_neighbors = 6
neighbours = Neighbours(xy_points, num_neighbors)
point = np.random.rand(2)
distances = neighbours.get_neighbours_wrapper(point)
print(distances)

核心疑问：传递类变量是否会阻止Numba的并行化？若是，可行解决方案是什么？

解答

1. 类变量本身不会阻止Numba并行化，真正的阻碍是这两点：

GIL锁限制：默认情况下，@njit装饰的函数会持有Python的GIL，即使你用多线程调用包装器方法，多个线程也会串行执行，无法真正并行。
Numba函数未启用并行逻辑：当前的get_neighbours_Numba是普通串行循环，没有配置并行执行，单线程的Numba函数自然无法利用多核。

传递类变量（self.xy_points、self.num_neighbors）本身不会成为并行障碍——Numba会正确处理这些传入的数组和数值，只要类变量是只读的（没有多线程同时修改），就不会有问题。

2. 可行解决方案

方案一：配置Numba函数释放GIL并启用内部并行

修改Numba装饰器，添加nogil=True让函数执行时释放GIL，同时用parallel=True和numba.prange启用循环并行：

import numba
import numpy as np
from numba import njit

@njit(parallel=True, nogil=True)
def get_neighbours_Numba(points: np.ndarray, num_neighbors: int):
    # 调整输出结构，为每个点存储距离
    distances = np.zeros((len(points), num_neighbors))
    # 用prange代替range，让Numba识别可并行的循环
    for i in numba.prange(len(points)):
        point = points[i]
        neighbours_indices_xy = np.zeros((num_neighbors, 2))
        ## 此处执行你的邻居计算逻辑
        # 为当前点的距离数组赋值
        distances[i] = ...
    return distances

这样单个Numba函数内部就能并行处理循环，同时释放GIL后，多线程调用包装器方法也能真正并行执行。

方案二：改用多进程绕过GIL限制

如果不想修改Numba函数的并行配置，可以用Python的multiprocessing模块创建多进程，每个进程独立持有GIL，能真正并行执行任务：

from multiprocessing import Pool
import numpy as np
from numba import njit

# 保留原Numba函数和类定义
@njit
def get_neighbours_Numba(points: np.ndarray, num_neighbors: int):
    # 原函数逻辑
    ...

# 定义进程任务函数
def process_task(args):
    point, xy_points, num_neighbors = args
    return get_neighbours_Numba(xy_points, num_neighbors)

# 示例用法
if __name__ == "__main__":
    xy_points = np.random.rand(100, 2)
    num_neighbors = 6
    # 准备多个任务
    tasks = [(np.random.rand(2), xy_points, num_neighbors) for _ in range(8)]
    
    # 启动进程池并行执行
    with Pool(processes=4) as pool:
        results = pool.map(process_task, tasks)
    
    # 处理结果
    print(results)

方案三：确保类变量的线程安全（可选）

如果你的Neighbours类存在多线程修改成员变量的场景，可以在包装器方法中复制类变量后传入Numba函数，避免并发冲突：

def get_neighbours_wrapper(self, point: np.ndarray):
    # 复制类变量（只读场景下可省略，这里是为了线程安全）
    points_copy = self.xy_points.copy()
    num_neighbors_copy = self.num_neighbors
    distances = get_neighbours_Numba(points_copy, num_neighbors_copy)
    return distances

如果类变量不会被修改，这一步完全不需要。

内容的提问来源于stack exchange，提问作者skm