暂停后恢复的Python多连接下载器使下载无休止地运行

Question

我编写了一个 Python 脚本，它使用 32 个连接(如果可用)下载单个文件。

我写了一个多连接下载器，不用暂停就可以正常工作，但在恢复后不会停止下载，进度会超过 100%...

像这样:

Download mode: Multi-thread (press Space to pause/resume, press Escape to stop)                                                                                                             
[████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████] 120% completed, paused: False                                    
Download mode: Multi-thread (press Space to pause/resume, press Escape to stop)                                                                                                             
1798.08 MiB downloaded, 1489.83 MiB total, -308.25 MiB remaining, download speed: 22.73 MiB/s                                                                                               
Minimum speed: 0.00 MiB/s, average speed: 4.54 MiB/s, maximum speed: 75.00 MiB/s                                                                                                            
Task started on 2021-08-09 16:57:03, 00:06:35 elapsed, ETA: -1:59:47

进度超过100%后，会出现这样的错误信息:

Exception in thread Thread-78:
Traceback (most recent call last):
  File "C:\Program Files\Python39\lib\threading.py", line 973, in _bootstrap_inner
    self.run()
  File "C:\Program Files\Python39\lib\threading.py", line 910, in run
    self._target(*self._args, **self._kwargs)
  File "D:\MyScript\downloader.py", line 70, in multidown
    mm[position: position+len(chunk)] = chunk
IndexError: mmap slice assignment is wrong size

(以上不包括所有错误信息)

恢复后我遇到了各种各样的错误，但最重要的是，服务器通常会从之前的请求中发送额外的字节，其连接已失效，不用说这会破坏整个代码。

我应该如何正确实现暂停和恢复？

我正在考虑多处理，我假设 session 和连接都是 PID 和端口号相关的，到目前为止我还没有遇到从以前的脚本运行中接收额外字节的新脚本运行，所以我猜测使用具有新 PID 和新端口号的另一个进程加上 requests.session() 加上 {'connection': 'close'} 每次下载应该保证没有额外的将接收来自先前连接的字节，我只是不知道如何在进程之间共享变量...

代码:downloader.py

import json
import keyboard
import os
import re
import requests
import sys
import time
import validators
from collections import deque
from datetime import datetime, timedelta
from math import inf
from mmap import mmap
from pathlib import Path
from ping3 import ping
from reprint import output
from threading import Thread


def timestring(sec):
    sec = int(sec)
    m, s = divmod(sec, 60)
    h, m = divmod(m, 60)
    return f'{h:02d}:{m:02d}:{s:02d}'


class Downloader:
    def __init__(self):
        self.recent = deque([0] * 12, maxlen=12)
        self.recentspeeds = deque([0] * 200, maxlen=200)
        self.paused = False
        self.progress = dict()

    class Multidown:
        def __init__(self, obj, id):
            self.count = 0
            self.position = 0
            self.completed = False
            self.id = id
            self.parent = obj
        
        def multidown(self, url, start, end):
            interrupted = False
            s = requests.session()
            s.headers.update({'connection': 'close', 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0'})
            r = s.get(
                url, headers={'range': 'bytes={0}-{1}'.format(start, end)}, stream=True)
            length = int(r.headers['content-length'])
            while end - length + (self.id != self.parent.progress['connections'] - 1) != start or r.status_code != 206:
                r.close()
                s.close()
                del r
                del s
                time.sleep(0.02)
                s = requests.session()
                r = s.get(
                    url, headers={'range': 'bytes={0}-{1}'.format(start, end)}, stream=True)
                length = int(r.headers['content-length'])
            self.position = start
            
            for chunk in r.iter_content(1048576):
                if self.parent.paused:
                    self.parent.mm.flush()
                    r.connection.close()
                    r.close()
                    s.close()
                    del r
                    del s
                    interrupted = True
                    break
                if chunk:
                    self.parent.mm[self.position: self.position+len(chunk)] = chunk
                    self.count += len(chunk)
                    self.position += len(chunk)
                    self.parent.progress[self.id]['count'] = self.count
                    self.parent.progress[self.id]['position'] = self.position
            if not interrupted:
                r.close()
                s.close()
            if self.count == self.parent.progress[self.id]['length']:
                self.completed = True
                self.parent.progress[self.id]['completed'] = True
                self.parent.mm.flush()
    
    class Singledown:
        def __init__(self):
            self.count = 0
        def singledown(self, url, path):
            with requests.get(url, stream=True) as r:
                with path.open('wb') as file:
                    for chunk in r.iter_content(1048576):
                        if chunk:
                            self.count += len(chunk)
                            file.write(chunk)

    def download(self, url, filepath, num_connections=32, overwrite=False):
        singlethread = False
        threads = []
        bcontinue = False
        filepath = filepath.replace('\\', '/')
        if (not re.match('^[a-zA-Z]:/(((?![<>:"/|?*]).)+((?<![ .])/)?)*$', filepath) or
                not Path(filepath[:3]).exists()):
            print('Invalid windows file path has been inputted, process will now stop.')
            return
        if not validators.url(url):
            print('Invalid url been inputted, process will now stop.')
            return
        if url.lower().startswith('ftp://'):
            print(
                "`requests` module doesn't suport File Transfer Protocol, process will now stop")
            return
        path = Path(filepath)
        if not path.exists():
            bcontinue = True
        else:
            if path.is_file():
                if overwrite:
                    bcontinue = True
                else:
                    while True:
                        answer = input(
                            f'`{filepath}` already exists, do you want to overwrite it? \n(Yes, No):').lower()
                        if answer in ['y', 'yes', 'n', 'no']:
                            if answer.startswith('y'):
                                os.remove(filepath)
                                bcontinue = True
                            break
                        else:
                            print('Invalid input detected, retaking input.')
        if not bcontinue:
            print(
                f'Overwritting {filepath} has been aborted, process will now stop.')
            return
        bcontinue = False
        server = url.split('/')[2]
        ok = ping(server, timeout=2)
        if ok == False:
            print(
                'The server of the inputted url is non-existent, process will now stop.')
            return
        if ok:
            bcontinue = True
        if not ok:
            print('Connection has timed out, will reattempt to ping server 5 times.')
            for i in range(5):
                print(
                    f'Reattempting to ping server, retrying {i + 1} out of 5')
                ok = ping(server, timeout=2)
                if ok:
                    print(
                        f'Connection successful on retry {i + 1}, process will now continue.')
                    bcontinue = True
                    break
                else:
                    print(f'Retry {i + 1} out of 5 timed out' + (i != 4)
                          * ', reattempting in 1 second.' + (i == 4) * '.')
                    time.sleep(1)
        if not bcontinue:
            print('Failed to connect server, connection timed out, process will now stop')
            return
        bcontinue = False
        head = requests.head(url)
        if head.status_code == 200:
            bcontinue = True
        else:
            for i in range(5):
                print(f'Server responce is invalid, retrying {i + 1} out of 5')
                head = requests.head(url)
                if head.status_code == 200:
                    print(
                        f'Connection successful on retry {i + 1}, process will now continue.')
                    bcontinue = True
                    break
                else:
                    print(f'Retry {i + 1} out of 5 failed to access data' +
                          (i != 4) * ', reattempting in 1 second.' + (i == 4) * '.')
                    time.sleep(1)
        if not bcontinue:
            print("Can't establish a connection with access to data, can't download target file, process will now stop.")
            return
        folder = '/'.join(filepath.split('/')[:-1])
        Path(folder).mkdir(parents=True, exist_ok=True)
        headers = head.headers
        total = headers.get('content-length')
        if not total:
            print(
                f'Cannot find the total length of the content of {url}, the file will be downloaded using a single thread.')
            started = datetime.now()
            print('Task started on %s.' %
                    started.strftime('%Y-%m-%d %H:%M:%S'))
            sd = self.Singledown()
            th = Thread(target=sd.singledown, args=(url, path))
            threads.append(sd)
            th.start()
            total = inf
            singlethread = True
        else:
            total = int(total)
            if not headers.get('accept-ranges'):
                print(
                    'Server does not support the `range` parameter, the file will be downloaded using a single thread.')
                started = datetime.now()
                print('Task started on %s.' %
                        started.strftime('%Y-%m-%d %H:%M:%S'))
                sd = self.Singledown()
                th = Thread(target=sd.singledown, args=(url, path))
                threads.append(sd)
                th.start()
                singlethread = True
            else:
                segment = total / num_connections
                started = datetime.now()
                lastpressed = started
                path.touch()
                file = path.open('wb')
                file.seek(total - 1)
                file.write(b'\0')
                file.close()
                file = path.open(mode='r+b')
                self.mm = mmap(file.fileno(), 0)
                print('Task started on %s.' %
                        started.strftime('%Y-%m-%d %H:%M:%S'))
                self.progress['total'] = total
                self.progress['connections'] = num_connections
                for i in range(num_connections):
                    md = self.Multidown(self, i)
                    start = int(segment * i)
                    end = int(segment * (i + 1)) - (i != num_connections - 1)
                    length = end - start + (i != num_connections - 1)
                    th = Thread(target=md.multidown, args=(
                        url, start, end))
                    threads.append(md)
                    self.progress[i] = dict()
                    self.progress[i]['start'] = start
                    self.progress[i]['position'] = start
                    self.progress[i]['end'] = end
                    self.progress[i]['count'] = 0
                    self.progress[i]['length'] = length
                    self.progress[i]['completed'] = False
                    th.start()
                Path(filepath + '.progress.json').write_text(json.dumps(self.progress, indent=4))
        downloaded = 0
        totalMiB = total / 1048576
        speeds = []
        interval = 0.04
        with output(initial_len=5, interval=0) as dynamic_print:
            while True:
                Path(filepath + '.progress.json').write_text(json.dumps(self.progress, indent=4))
                status = sum([i.completed for i in threads])
                downloaded = sum(i.count for i in threads)
                self.recent.append(downloaded)
                done = int(100 * downloaded / total)
                doneMiB = downloaded / 1048576
                gt0 = len([i for i in self.recent if i])
                if not gt0:
                    speed = 0
                else:
                    recent = list(self.recent)[12 - gt0:]
                    if len(recent) == 1:
                        speed = recent[0] / 1048576 / interval
                    else:
                        diff = [b - a for a, b in zip(recent, recent[1:])]
                        speed = sum(diff) / len(diff) / 1048576 / interval
                speeds.append(speed)
                self.recentspeeds.append(speed)
                nzspeeds = [i for i in speeds if i]
                if nzspeeds:
                    minspeed = min(nzspeeds)
                else:
                    minspeed = 0
                maxspeed = max(speeds)
                now = datetime.now()
                elapsed = (now - started).total_seconds()
                meanspeed = downloaded / elapsed / 1048576
                remaining = totalMiB - doneMiB
                dynamic_print[0] = '[{0}{1}] {2}'.format(
                    '\u2588' * done, '\u00b7' * (100-done), str(done)) + '% completed' + (not singlethread) * ', paused: {0}'.format(self.paused)
                dynamic_print[1] = 'Download mode: ' + singlethread * \
                    'Single-thread' + (not singlethread) * 'Multi-thread (press Space to pause/resume, press Escape to stop)'
                dynamic_print[2] = '{0:.2f} MiB downloaded, {1:.2f} MiB total, {2:.2f} MiB remaining, download speed: {3:.2f} MiB/s'.format(
                    doneMiB, totalMiB, remaining, speed)
                if speed and total != inf:
                    eta = timestring(remaining / speed)
                else:
                    eta = '99:59:59'
                dynamic_print[3] = 'Minimum speed: {0:.2f} MiB/s, average speed: {1:.2f} MiB/s, maximum speed: {2:.2f} MiB/s'.format(
                    minspeed, meanspeed, maxspeed)
                dynamic_print[4] = 'Task started on {0}, {1} elapsed, ETA: {2}'.format(
                    started.strftime('%Y-%m-%d %H:%M:%S'), timestring(elapsed), eta)
                if keyboard.is_pressed('space'):
                    if not singlethread:
                        pressed = datetime.now()
                        if (pressed - lastpressed).total_seconds() > 0.5:
                            lastpressed = pressed
                            if self.paused:
                                for i, md in enumerate(threads):
                                    if not md.completed:
                                        th = Thread(target=md.multidown, args=(
                                            url, self.progress[i]['position'], self.progress[i]['end']))
                                        th.start()
                            self.paused = not self.paused
                if keyboard.is_pressed('esc'):
                    if not singlethread:
                        ended = datetime.now()
                        self.paused = True
                        break
                if status == len(threads):
                    if not singlethread:
                        self.mm.close()
                    ended = datetime.now()
                    break
                time.sleep(interval)
        time_spent = (ended - started).total_seconds()
        meanspeed = total / time_spent / 1048576
        status = sum([i.completed for i in threads])
        if status == len(threads):
            print('Task completed on {0}, total time elapsed: {1}, average speed: {2:.2f} MiB/s'.format(
                ended.strftime('%Y-%m-%d %H:%M:%S'), timestring(time_spent), meanspeed))
        else:
            print('Task interrupted on {0}, total time elapsed: {1}, average speed: {2:.2f} MiB/s'.format(
                ended.strftime('%Y-%m-%d %H:%M:%S'), timestring(time_spent), meanspeed))

if __name__ == '__main__':
    d = Downloader()
    d.download(*sys.argv[1:])

出于测试目的，这是脚本的简化版本，删除了所有检查，同时保留了相同的功能(抱歉，它确实需要所有这些行来显示下载信息):

import json
import os
import requests
import sys
import time
from collections import deque
from datetime import datetime, timedelta
from math import inf
from mmap import mmap
from pathlib import Path
from reprint import output
from threading import Thread


def timestring(sec):
    sec = int(sec)
    m, s = divmod(sec, 60)
    h, m = divmod(m, 60)
    return f'{h:02d}:{m:02d}:{s:02d}'


class Downloader:
    def __init__(self):
        self.recent = deque([0] * 12, maxlen=12)
        self.recentspeeds = deque([0] * 200, maxlen=200)
        self.paused = False
        self.progress = dict()
        self.UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0'

    class Multidown:
        def __init__(self, obj, id):
            self.count = 0
            self.position = 0
            self.completed = False
            self.id = id
            self.parent = obj
            self.UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Firefox/91.0'
        
        def multidown(self, url, start, end):
            interrupted = False
            s = requests.session()
            s.headers.update({'connection': 'close', 'user-agent': self.UA})
            r = s.get(
                url, headers={'range': 'bytes={0}-{1}'.format(start, end)}, stream=True)
            length = int(r.headers['content-length'])
            while end - length + (self.id != self.parent.progress['connections'] - 1) != start or r.status_code != 206:
                r.close()
                s.close()
                del r
                del s
                time.sleep(0.02)
                s = requests.session()
                r = s.get(
                    url, headers={'range': 'bytes={0}-{1}'.format(start, end)}, stream=True)
                length = int(r.headers['content-length'])
            self.position = start
            
            for chunk in r.iter_content(1048576):
                if self.parent.paused:
                    self.parent.mm.flush()
                    r.connection.close()
                    r.close()
                    s.close()
                    del r
                    del s
                    interrupted = True
                    break
                if chunk:
                    self.parent.mm[self.position: self.position+len(chunk)] = chunk
                    self.count += len(chunk)
                    self.position += len(chunk)
                    self.parent.progress[self.id]['count'] = self.count
                    self.parent.progress[self.id]['position'] = self.position
            if not interrupted:
                r.close()
                s.close()
            if self.count == self.parent.progress[self.id]['length']:
                self.completed = True
                self.parent.progress[self.id]['completed'] = True
                self.parent.mm.flush()
    

    def download(self, url, filepath, num_connections=32, overwrite=False):
        singlethread = False
        threads = []
        bcontinue = False
        filepath = filepath.replace('\\', '/')
        if Path(filepath).exists():
            os.remove(filepath)
        folder = '/'.join(filepath.split('/')[:-1])
        Path(folder).mkdir(parents=True, exist_ok=True)
        head = requests.head(url, headers={'user-agent': self.UA})
        path = Path(filepath)
        headers = head.headers
        total = headers.get('content-length')
        if total:
            total = int(total)
            if headers.get('accept-ranges'):
                segment = total / num_connections
                started = datetime.now()
                lastpressed = started
                path.touch()
                file = path.open('wb')
                file.seek(total - 1)
                file.write(b'\0')
                file.close()
                file = path.open(mode='r+b')
                self.mm = mmap(file.fileno(), 0)
                print('Task started on %s.' %
                        started.strftime('%Y-%m-%d %H:%M:%S'))
                self.progress['total'] = total
                self.progress['connections'] = num_connections
                for i in range(num_connections):
                    md = self.Multidown(self, i)
                    start = int(segment * i)
                    end = int(segment * (i + 1)) - (i != num_connections - 1)
                    length = end - start + (i != num_connections - 1)
                    th = Thread(target=md.multidown, args=(
                        url, start, end))
                    threads.append(md)
                    self.progress[i] = dict()
                    self.progress[i]['start'] = start
                    self.progress[i]['position'] = start
                    self.progress[i]['end'] = end
                    self.progress[i]['count'] = 0
                    self.progress[i]['length'] = length
                    self.progress[i]['completed'] = False
                    th.start()
                Path(filepath + '.progress.json').write_text(json.dumps(self.progress, indent=4))
        downloaded = 0
        totalMiB = total / 1048576
        speeds = []
        interval = 0.04
        with output(initial_len=5, interval=0) as dynamic_print:
            while True:
                Path(filepath + '.progress.json').write_text(json.dumps(self.progress, indent=4))
                status = sum([i.completed for i in threads])
                downloaded = sum(i.count for i in threads)
                self.recent.append(downloaded)
                done = int(100 * downloaded / total)
                doneMiB = downloaded / 1048576
                gt0 = len([i for i in self.recent if i])
                if not gt0:
                    speed = 0
                else:
                    recent = list(self.recent)[12 - gt0:]
                    if len(recent) == 1:
                        speed = recent[0] / 1048576 / interval
                    else:
                        diff = [b - a for a, b in zip(recent, recent[1:])]
                        speed = sum(diff) / len(diff) / 1048576 / interval
                speeds.append(speed)
                self.recentspeeds.append(speed)
                nzspeeds = [i for i in speeds if i]
                if nzspeeds:
                    minspeed = min(nzspeeds)
                else:
                    minspeed = 0
                maxspeed = max(speeds)
                now = datetime.now()
                elapsed = (now - started).total_seconds()
                meanspeed = downloaded / elapsed / 1048576
                remaining = totalMiB - doneMiB
                dynamic_print[0] = '[{0}{1}] {2}'.format(
                    '\u2588' * done, '\u00b7' * (100-done), str(done)) + '% completed' + (not singlethread) * ', paused: {0}'.format(self.paused)
                dynamic_print[1] = 'Download mode: ' + singlethread * \
                    'Single-thread' + (not singlethread) * 'Multi-thread (press Space to pause/resume, press Escape to stop)'
                dynamic_print[2] = '{0:.2f} MiB downloaded, {1:.2f} MiB total, {2:.2f} MiB remaining, download speed: {3:.2f} MiB/s'.format(
                    doneMiB, totalMiB, remaining, speed)
                if speed and total != inf:
                    eta = timestring(remaining / speed)
                else:
                    eta = '99:59:59'
                dynamic_print[3] = 'Minimum speed: {0:.2f} MiB/s, average speed: {1:.2f} MiB/s, maximum speed: {2:.2f} MiB/s'.format(
                    minspeed, meanspeed, maxspeed)
                dynamic_print[4] = 'Task started on {0}, {1} elapsed, ETA: {2}'.format(
                    started.strftime('%Y-%m-%d %H:%M:%S'), timestring(elapsed), eta)
                if PAUSE:
                    if not singlethread:
                        pressed = datetime.now()
                        if (pressed - lastpressed).total_seconds() > 0.5:
                            lastpressed = pressed
                            if self.paused:
                                for i, md in enumerate(threads):
                                    if not md.completed:
                                        th = Thread(target=md.multidown, args=(
                                            url, self.progress[i]['position'], self.progress[i]['end']))
                                        th.start()
                            self.paused = not self.paused
                if status == len(threads):
                    if not singlethread:
                        self.mm.close()
                    ended = datetime.now()
                    break
                time.sleep(interval)
        time_spent = (ended - started).total_seconds()
        meanspeed = total / time_spent / 1048576
        status = sum([i.completed for i in threads])
        if status == len(threads):
            print('Task completed on {0}, total time elapsed: {1}, average speed: {2:.2f} MiB/s'.format(
                ended.strftime('%Y-%m-%d %H:%M:%S'), timestring(time_spent), meanspeed))
        else:
            print('Task interrupted on {0}, total time elapsed: {1}, average speed: {2:.2f} MiB/s'.format(
                ended.strftime('%Y-%m-%d %H:%M:%S'), timestring(time_spent), meanspeed))

if __name__ == '__main__':
    import hashlib
    global PAUSE
    PAUSE = False
    chash = '5674E59283D95EFE8C88770515A9BBC80CBB77CB67602389FD91DEF26D26AED2'
    d = Downloader()
    if sys.argv[1] == '0':
        d.download('http://ipv4.download.thinkbroadband.com/1GB.zip', 'C:/test/1GB.zip')
    elif sys.argv[1] == '1':
        th1 = Thread(target=d.download, args=('http://ipv4.download.thinkbroadband.com/1GB.zip', 'C:/test/1GB.zip'))
        th1.start()
        def test():
            while th1.is_alive():
                global PAUSE
                PAUSE = not PAUSE
                time.sleep(10)
        th2 = Thread(target=test)
        th2.start()
        while th1.is_alive():
            pass
    sha256_hash = hashlib.sha256()
    with open('C:/test/1GB.zip',"rb") as f:
        for byte_block in iter(lambda: f.read(1048576),b""):
            sha256_hash.update(byte_block)
    print(sha256_hash.hexdigest().lower() == chash.lower())

如果在我的区域设置中没有 VPN，则无法访问该 url，并且 test 0 总是结果 True，也就是说，如果连接在测试期间没有中断下载，测试 1 有时结果为 True，有时结果为 False，有时没有完成(进度条超过 100%).. .

如何挽救我的代码？

Answer 1

这可能不是您唯一的问题，但如果您快速暂停和恢复(快速的定义因您的情况而异)，可能会出现竞争条件。假设您有 32 个线程，每个线程都请求一个 MB block ，我们称它们为线程 0-31。他们正在下载，你暂停。线程不知道你暂停了，直到它们在阻塞 io 中获得一大块数据。不确定您的连接速度或您的机器有多少个内核(线程有时会在不需要 GIL 时并行操作)，但此过程可能比您预期的要长得多。然后你取消暂停，你的代码创建新的线程 32-63，但线程 0-31 的部分或全部仍在等待下一个 block 。您启动线程 32-63，然后关闭暂停标志。那些不是从 0-31 结束的线程随后醒来，发现事情没有暂停。现在您有多个线程访问相同的状态变量

self.parent.mm[self.position: self.position + len(chunk)] = chunk
self.count += len(chunk)
self.position += len(chunk)
self.parent.progress[self.id]['count'] = self.count
self.parent.progress[self.id]['position'] = self.position

因此，如果线程 0 正在下载与线程 31 相同的 block ，它们都会保持更新所有相同的状态，并且它们会添加位置和计数，即使它们正在下载文件的重叠部分。您甚至可以重用线程所在的对象，这样状态就会变得非常困惑。

for i, md in enumerate(threads):
    if not md.completed:
        th = Thread(target=md.multidown, args=(url, self.progress[i]['position'], self.progress[i]['end']))
        th.start()

您的代码中可能还有一些其他问题，需要整理的内容很多，因此我建议花时间进行一些重构，以消除重复代码并将内容组织成更多函数。我不相信疯狂的小函数，但你可以使用一些子函数，比如 download_multi(download_state) 和 download_single。但是，我相对有信心，如果您确保您正在运行的线程在暂停后实际结束，那么您当前的问题将会得到解决。为此，您需要实际保存对线程的引用

某处:

actual_threads = []

当你创建你的线程时(第一次和你取消暂停后，或者最好是在一个函数中，你会在那里创建并返回列表):

th = Thread(target=md.multidown, args=(
                        url, start, end))
threads.append(md)
actual_threads.append(th)

然后当你取消暂停时:

self.paused = not self.paused
for th in actual_threads:
    th.join()

这样您就可以让线程正常工作，当您暂停时它们会退出并重新构建它们。所以 join 应该在他们打破对 iter_content 的阻塞 io 调用时立即返回。这样，在您创建新线程之前，这些线程总是已死。

然而，我自己会做的是创建从每个线程到主进程的套接字。当检测到暂停时，线程会关闭请求并保存已经在操作系统缓冲区中等待的所有数据，然后进入套接字上的阻塞接收(可能有一种方法可以将 select 与套接字和请求一起使用，甚至可以中断立即脱离 r.iter_content 中涉及的阻塞 io，但我将其留给您研究)。当程序未暂停时，主进程将发送一些值以指示程序应该重新启动(您需要至少两个线程可以识别的信号，一个用于正常退出，一个用于恢复。代码可以是单个字符。)该值被发送到每个线程，该线程将解除阻塞，然后可以使用请求和之前的状态重新开始下载，就像什么都没发生一样。