多进程/多线程优化百万点位灰度图生成程序遇阻：ThreadPool无提速、ProcessPool执行异常

咱们先拆解你遇到的两个核心问题，再给出针对性的优化方案：

1. ThreadPoolExecutor 未提速的原因 #

Python的**全局解释器锁（GIL）**是关键障碍：对于你这种CPU密集型任务（循环计算灰度值、修改像素），多线程实际上是串行执行的——同一时间只有一个线程能执行Python字节码，线程切换还会带来额外开销，所以耗时和串行版本几乎一致，甚至可能更慢。线程池更适合IO密集型任务（比如网络请求、文件读写），CPU密集型任务得用多进程绕开GIL。

2. ProcessPoolExecutor 仅执行第一个值的问题 #

多进程之间是内存完全隔离的，你的Process函数依赖的全局变量（df、offsets、pixels等）并不会自动共享给子进程：

• 子进程会复制主进程的内存空间，但PIL的PixelAccess对象（也就是pixels）无法被正确序列化/复制，子进程修改的只是自己的副本，不会影响主进程的图像；
• 你没有把依赖变量作为参数传递给Process函数，子进程中可能无法正确访问这些变量，导致循环提前终止（比如df在子进程中未正确初始化，len(df)为0，循环直接结束）。

另外，你的任务拆分逻辑也有小疏漏：没有处理thread_rest的剩余数据，最后会有thread_rest条数据没被处理。

可行的性能优化方案 #

第一步：先优化串行代码的瓶颈（立竿见影） #

你的串行代码有两个明显的性能短板，先优化这些，可能不用多进程就能大幅提速：

优化1：用pandas直接读取CSV，替换自定义的CreateDataFrame

自己逐行读取分割的效率远低于pandas内置的解析器：

# 替换原来的CreateDataFrame函数
columns = ['x', 'z', 'y']
df = pd.read_csv('raw data.csv', sep=' ', names=columns, header=None)

这一步能把DataFrame的创建速度提升数倍。

优化2：将DataFrame转为numpy数组，避免iloc的低效访问

df.iloc[i]是逐行访问，速度极慢，转为numpy数组后用索引访问+矢量化计算，能把循环耗时降低一个数量级：

# 把df转为numpy数组
data = df.to_numpy()

# 提前计算y的灰度映射参数
y_min = offsets['y']
y_max = maximums['y']
# 矢量化计算所有y对应的灰度值
grays = ((data[:, 2] - y_min) / y_max * 255).astype(int)

# 矢量化计算x和z的像素坐标
x_coords = ((maximums['x'] - (data[:, 0] - offsets['x'])) * scale).astype(int)
z_coords = ((data[:, 1] - offsets['z']) * scale).astype(int)

# 批量赋值像素
pixels = img.load()
print('Printing ... ', end='')
for x, z, gray in zip(x_coords, z_coords, grays):
    pixels[x, z] = (gray, gray, gray)
print('done')

第二步：多进程优化（如果还需要更快） #

如果优化串行后还是不够快，可以用多进程，但要避免共享图像对象，改为让每个进程处理一部分数据，生成坐标和灰度值，最后主进程统一赋值：

import concurrent.futures
import numpy as np

def process_chunk(chunk_data, y_min, y_max, max_x, x_offset, z_offset, scale):
    # 处理一个数据块，返回(x坐标, z坐标, 灰度值)的数组
    y_vals = chunk_data[:, 2]
    grays = ((y_vals - y_min) / y_max * 255).astype(int)
    x_coords = ((max_x - (chunk_data[:, 0] - x_offset)) * scale).astype(int)
    z_coords = ((chunk_data[:, 1] - z_offset) * scale).astype(int)
    return np.column_stack((x_coords, z_coords, grays))

# 准备数据
data = df.to_numpy()
y_min = offsets['y']
y_max = maximums['y']
max_x = maximums['x']
x_offset = offsets['x']
z_offset = offsets['z']

# 拆分数据块（建议进程数设为CPU核心数）
nb_process = 8
chunk_size = len(data) // nb_process
chunks = [data[i*chunk_size : (i+1)*chunk_size] for i in range(nb_process)]
# 处理剩余数据
if len(data) % nb_process != 0:
    chunks.append(data[nb_process*chunk_size:])

# 多进程处理
with concurrent.futures.ProcessPoolExecutor(max_workers=nb_process) as executor:
    futures = [executor.submit(process_chunk, chunk, y_min, y_max, max_x, x_offset, z_offset, scale) for chunk in chunks]
    # 收集所有结果
    all_results = []
    for future in concurrent.futures.as_completed(futures):
        all_results.append(future.result())

# 主进程统一赋值像素
print('Printing ... ', end='')
pixels = img.load()
for result in all_results:
    for x, z, gray in result:
        pixels[x, z] = (gray, gray, gray)
print('done')

这种方式的好处是：

• 子进程只处理数据计算，不操作图像，避免了跨进程共享图像的问题；
• 用numpy数组传递数据，效率远高于逐行传递；
• 充分利用多核CPU的优势，进一步提升速度。

额外优化：用numpy直接操作图像数组 #

如果你的图像尺寸不是特别大，可以把图像转为numpy数组，批量赋值像素，速度会更快：

import numpy as np

# 创建numpy数组形式的黑色背景图像
img_np = np.zeros((int(maximums['z'] * scale) + 1, int(maximums['x'] * scale) + 1, 3), dtype=np.uint8)
# 批量赋值灰度值（注意：PIL是(x,y)坐标，numpy是(y,x)顺序）
img_np[z_coords, x_coords] = np.stack((grays, grays, grays), axis=1)
# 转为PIL图像并保存
img = Image.fromarray(img_np)
img.save(f'terrain {scale}.png')

这种批量赋值的方式比逐个修改pixels快得多，因为numpy是C实现的矢量化操作。

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