在python中暂停和恢复线程

Question

我需要暂停和恢复线程，该线程不断执行某些任务。 执行在start()被调用时start() ，它不应被中断，并且必须从pause()被调用的那一刻start()执行。

我该怎么做？

Answer 1

请记住，在 Pythin 中使用线程不会授予您并行处理，除非 IO 阻塞操作的情况。 有关此的更多信息，请查看此和此

您不能在 Python 中任意暂停线程（在进一步阅读之前请记住这一点）。 我不确定你有没有办法在操作系统级别做到这一点（例如，通过使用纯 C）。 您可以做的是允许线程在您事先考虑的特定点暂停。 我给你举个例子：

class MyThread(threading.Thread):

    def __init__(self, *args, **kwargs):
        super(MyThread, self).__init__(*args, **kwargs)
        self._event = threading.Event()

    def run(self):
        while True:
            self.foo() # please, implement this.
            self._event.wait()
            self.bar() # please, implement this.
            self._event.wait()
            self.baz() # please, implement this.
            self._event.wait()

    def pause(self):
        self._event.clear()

    def resume(self):
        self._event.set()

这种方法会奏效，但：

• 根据我给你的链接，线程通常是一个坏主意。
• 您必须使用这种方法自己编写 run 方法。 这是因为您需要控制要检查暂停的确切点，这意味着访问 Thread 对象（也许您想创建一个额外的方法而不是调用self._event.wait() ） .
• 前一点清楚地表明你不能随意暂停，但只要你指定你就可以暂停。 避免在暂停点之间进行长时间的操作。

编辑我没有测试这个，但如果你需要多个这样的线程，也许这会在没有这么多子类化的情况下工作：

class MyPausableThread(threading.Thread):

    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self._event = threading.Event()
        if target:
            args = (self,) + args
        super(MyPausableThread, self).__init__(group, target, name, args, kwargs)

    def pause(self):
        self._event.clear()

    def resume(self):
        self._event.set()

    def _wait_if_paused(self):
        self._event.wait()

这应该允许您通过调用MyPausableThread(target=myfunc).start()创建一个没有更多子类化的自定义线程，并且您的可调用对象的第一个参数将接收线程对象，您可以在需要时从中调用self._wait_if_paused()暂停检查。

或者甚至更好，如果您想将目标与访问线程对象隔离开来：

class MyPausableThread(threading.Thread):

    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        self._event = threading.Event()
        if target:
            args = ((lambda: self._event.wait()),) + args
        super(MyPausableThread, self).__init__(group, target, name, args, kwargs)

    def pause(self):
        self._event.clear()

    def resume(self):
        self._event.set()

并且您的目标可调用对象将在第一个参数中接收一个可以像这样调用的函数： pause_checker() （前提是目标可调用对象中的第一个参数名为pause_checker ）。

Answer 2

您可以通过附加导致所有其他线程等待信号的跟踪函数来实现此目的：

import sys
import threading
import contextlib

# needed to enable tracing
if not sys.gettrace():
    sys.settrace(lambda *args: None)

def _thread_frames(thread):
    for thread_id, frame in sys._current_frames().items():
        if thread_id == thread.ident:
            break
    else:
        raise ValueError("No thread found")
    # walk up to the root
    while frame:
        yield frame
        frame = frame.f_back


@contextlib.contextmanager
def thread_paused(thread):
    """ Context manager that pauses a thread for its duration """
    # signal for the thread to wait on
    e = threading.Event()

    for frame in _thread_frames(thread):
        # attach a new temporary trace handler that pauses the thread

        def new(frame, event, arg, old = frame.f_trace):
            e.wait()

            # call the old one, to keep debuggers working
            if old is not None:
                return old(frame, event, arg)
        frame.f_trace = new

    try:
        yield
    finally:
        # wake the other thread
        e.set()

您可以将其用作：

import time

def run_after_delay(func, delay):
    """ Simple helper spawning a thread that runs a function in the future """
    def wrapped():
        time.sleep(delay)
        func()
    threading.Thread(target=wrapped).start()

main_thread = threading.current_thread()

def interrupt():
    with thread_paused(main_thread):
        print("interrupting")
        time.sleep(2)
        print("done")

run_after_delay(interrupt, 1)
start = time.time()
def actual_time(): return time.time() - start

print("{:.1f} == {:.1f}".format(0.0, actual_time()))
time.sleep(0.5)
print("{:.1f} == {:.1f}".format(0.5, actual_time()))
time.sleep(2)
print("{:.1f} != {:.1f}".format(2.5, actual_time()))

给予

0.0 0.0
0.5 0.5
interrupting
done
2.5 3.0

请注意中断如何导致主线程上的睡眠等待更长时间

Answer 3

您可以使用psutil库中的Process类来执行此操作。

示例：

>>> import psutil
>>> pid = 7012
>>> p = psutil.Process(pid)
>>> p.suspend()
>>> p.resume()

看到这个答案： https : //stackoverflow.com/a/14053933

编辑：此方法将挂起整个进程，而不仅仅是一个线程。 （我不会删除这个答案，所以其他人可以知道这个方法行不通。）

Answer 4

while(int(any) < 2000):
             sleep(20)
             print(waiting any...)