GUI卡顿根源为inRegularIntervals函数，求优化及线程/进程选择建议

问题背景 #

已定位GUI卡顿根源是inRegularIntervals()函数，该函数负责将数字数组按固定区间分类，示例分类结果如下：

{0: [1, 0, 0, 1, 0, 0, 0], 10: [10, 18], 20: [28], 30: [], 40: [], 50: [], 60: [], 70: [70, 73, 73, 75], 80: [80], 90: [], 100: [106], 110: [], 120: [], 130: [], 140: [140], 150: [150], 160: [], 170: [170], 180: [], 190: [194, 196], 200: [200, 202], 210: [], 220: [], 230: [], 240: [], 250: [], 260: [], 270: [], 280: [], 290: [], 300: [], 310: [], 320: [], 330: [336], 340: [], 350: [353, 356]...}

原逻辑代码实现：

def inRegularIntervals(data, interval):
     """Sorts elements of data into bins of regular sizes.
     The size of each bin is given by 'interval'."""
     # init dict so keys are ordered - collection.defaultdict(list) 
     # would be faster - but this works for lists of a couple of
     # thousand numbers if you have a quarter up to one second ...

     # if random key order is ok, shorten this to d = {} 
        
     d = {k:[] for k in range(0, max(data), interval)}  
     for n in data:
        key = n // interval # get key
        key *= interval
        d.setdefault(key, [])
        d[key].append(n) # add number
        
     return d

# 构建未排序数组
transactions_NOT_sorted.append(int(round(amount))) 

# 按区间分类
transactions_sorted = inRegularIntervals(transactions_NOT_sorted,10)

# 统计每个区间的元素数量
for key, value in transactions_sorted.items():         
        count_items = len([item for item in value if item])
        if count_items > 0:
             data_for_plot[key]=count_items

现需优化该逻辑性能，纠结选择线程还是多进程？

优化分析与方案 #

1. 优先做单进程性能优化（性价比最高） #

原代码存在多个可快速修复的性能瓶颈，优化后多数场景下可直接解决GUI卡顿：

• 去掉预先创建空列表字典的操作：{k:[] for k in range(0, max(data), interval)}会生成大量无意义空列表，改用collections.defaultdict(list)或普通字典更高效。
• 简化统计逻辑：len([item for item in value if item])无需生成新列表，若统计非零元素用sum(1 for num in value if num)，若统计所有元素直接用len(value)。
• 直接计数而非存储元素：如果只需要区间元素数量，无需保存每个区间的具体元素，直接计数可大幅降低内存占用和时间开销。

优化后的单进程代码：

from collections import defaultdict

def count_intervals(data, interval):
    counter = defaultdict(int)
    for n in data:
        key = (n // interval) * interval
        counter[key] += 1
    # 过滤计数为0的区间（按需保留）
    return {k: v for k, v in counter.items() if v > 0}

# 直接得到统计结果，无需后续循环
data_for_plot = count_intervals(transactions_NOT_sorted, 10)

2. 线程还是多进程？ #

若单进程优化后仍无法满足性能需求（如数据量达百万/千万级），再考虑并发方案：

• 线程不适用：Python的GIL（全局解释器锁）会限制CPU密集型任务的并行执行，线程切换反而会增加额外开销，无法提升性能。
• 多进程是正确选择：多进程可绕过GIL，利用多核CPU并行处理数据。将数据分片后分配给不同进程，最后合并统计结果即可。

多进程实现示例：

from collections import defaultdict
from multiprocessing import Pool

def process_chunk(chunk, interval):
    counter = defaultdict(int)
    for n in chunk:
        key = (n // interval) * interval
        counter[key] += 1
    return counter

def count_intervals_multiprocess(data, interval, num_processes=None):
    # 分割数据为多个分片
    chunk_size = len(data) // (num_processes or 4)
    chunks = [data[i:i+chunk_size] for i in range(0, len(data), chunk_size)]
    
    with Pool(num_processes) as pool:
        # 并行处理每个分片
        results = pool.starmap(process_chunk, [(chunk, interval) for chunk in chunks])
    
    # 合并结果
    final_counter = defaultdict(int)
    for res in results:
        for key, count in res.items():
            final_counter[key] += count
    return {k: v for k, v in final_counter.items() if v > 0}

# 使用多进程统计
data_for_plot = count_intervals_multiprocess(transactions_NOT_sorted, 10)

总结 #

1. 优先完成单进程优化：去掉冗余操作、直接计数，这是解决问题最快速有效的方式。
2. 仅当数据量极大、单进程优化仍不足时，选择多进程而非线程，充分利用多核CPU资源。

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