文件 I/O 操作是否会在 Python 中释放 GIL？

Question

根据我阅读的内容 - 例如here - 我了解 I/O 操作会释放 GIL。所以，如果我必须读取本地文件系统上的大量文件，我的理解是线程执行应该加快速度。

为了测试这一点——我有一个文件夹 (input)，里面有大约 100k 个文件——每个文件只有一行和一个随机整数。我有两个函数 - 一个“顺序”和一个“并发”，只是添加所有数字

import glob
import concurrent.futures
ALL_FILES = glob.glob('./input/*.txt')
  
def extract_num_from_file(fname):
    #time.sleep(0.1)
    with open(fname, 'r') as f:
        file_contents = int(f.read().strip())
    return file_contents

def seq_sum_map_based():
   return sum(map(extract_num_from_file, ALL_FILES)) 

def conc_sum_map_based():
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        return sum(executor.map(extract_num_from_file, ALL_FILES))

虽然这两个函数给我的结果相同 - “并发”版本慢了大约 3-4 倍。

In [2]: %timeit ss.seq_sum_map_based()                                                                                                     
3.77 s ± 50.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [3]: %timeit ss.conc_sum_map_based()                                                                                                    
12.8 s ± 240 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

我的代码或我的理解有问题吗？

Answer 1

注意：以下内容仅适用于具有可影响读取吞吐量的移动部件的 HDD，不适用于 SDD。巨大的性能差异的性质使我很清楚这是一个面向 HDD 的问题，因此这些信息是在该假设下运行的。

问题在于，虽然线程可能并行运行，但必须从硬盘驱动器按顺序读取数据，因为只有单个读取头。然而，更糟糕的是，由于您已经并行化了 I/O 操作，底层操作系统将调度这些 I/O 任务，以便在切换到另一个线程之前仅部分处理这些文件——毕竟，即使您只有一个整数，文件头仍然需要处理 - 导致读取头比您严格的顺序代码更疯狂地跳跃。与简单地按顺序读取每个文件的整体相比，所有这些都会导致开销大大增加，这不需要太多的跳转。

例如，如果您有一个线程从磁盘加载大量数据，而第二个线程对其执行一些耗时的处理，那么这不会是一个大问题，因为这样可以节省时间- 密集处理以继续不受 I/O 操作的阻塞。您的特定场景只是一个非常非常糟糕的情况，您放弃了 GIL 瓶颈以换取极其缓慢的 I/O 瓶颈。

简而言之，您已经正确理解 I/O 操作会释放 GIL，但您只是对并行化文件读取得出了错误的结论。

Answer 2

另一个答案很好地说明了这一点：

您已经放弃了 GIL 瓶颈以换取极其缓慢的 I/O 瓶颈。简而言之，您已经正确理解了 I/O 操作释放了 GIL，您只是对并行文件读取得出了错误的结论。

我将补充一点，如果您有空闲的 I/O，读取线程文件的性能可以更高，就像在非常快的 SSD 上一样。

我在一个相对较快的 SSD（Samsung 970 EVO 1TB；没有活动的辅助驱动器）上进行了测试，从大约 1000 个不同大小的文件中读取，平均 8800 个字符。在测试中，我通过更多线程获得了更好的性能......但收益递减很快。

In [1]: len(ALL_FILES)
995
In [2]: %timeit ThreadedFileReader(ALL_FILES, n=1).join() # single threaded
61.8 ms ± 305 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [3]: %timeit ThreadedFileReader(ALL_FILES, n=2).join()
54.7 ms ± 158 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [4]: %timeit ThreadedFileReader(ALL_FILES, n=3).join()
56.1 ms ± 135 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [5]: %timeit ThreadedFileReader(ALL_FILES, n=4).join()
57.8 ms ± 131 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [6]: %timeit ThreadedFileReader(ALL_FILES, n=5).join()
58.9 ms ± 236 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [7]: %timeit ThreadedFileReader(ALL_FILES, n=50).join()
68.6 ms ± 378 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

因此，您的想法原则上是合理的，但前提是您有足够的 I/O 空闲，与顺序读取相比。除非您有非常快的存储空间，否则您可能只需要一两个额外的线程。如果您的存储根本不快，那么单线程方法可能是要走的路。

请记住，如果您有多个线程同时读取文件，尤其是小文件，您可能会受到驱动器的随机读取能力的限制。相比之下，处理大文件的单线程方法可能会在更接近驱动器的顺序读取功能时遇到瓶颈。根据硬件的不同，这些性能等级可能会有很大的不同。

根据您正在读取的数据的硬件和特性，顺序读取性能的好处可能超过并行读取的任何潜在收益。

为了完整起见，我用来测试的代码如下，尽管它对答案没有特别的影响。

class ThreadedFileReader:
    def __init__(self, files, n=5):
        self.files = deque(files)
        self.threads = []
        self.results = queue.Queue()
        for _ in range(n):
            t = threading.Thread(target=self.worker)
            t.start()
            self.threads.append(t)
    def worker(self):
        while self.files:
            fname = self.files.pop()
            with open(fname, encoding='utf-8') as f:
                data = f.read()
            self.results.put(len(data))
        return
    def join(self):
        for t in self.threads:
            t.join()