Detailed explanation of Python thread's pause, resume, and exit example code

python thread pause, resume, exit

We all know that the threading module in python can implement multi-threading, but the module does not provide pause, resume and exit To stop a thread, once the thread object calls the start method, it can only wait until the corresponding method function is completed. In other words, once started, the thread is out of control. However, we can implement this ourselves. The general method is to loop Determine a flag bit, and once the flag bit reaches a predetermined value, exit the loop. In this way, the thread can be exited. But suspending and resuming the thread is a bit difficult, and I have not found any good methods until I When you see the description of the wait method of the Event object in threading.

wait([timeout])

  Block until the internal flag is true. If the internal flag is true on entry, return immediately. Otherwise, block until another thread calls set() to set the flag to true, or until the optional timeout occurs.

  阻塞, 直到内部的标志位为True时. 如果在内部的标志位在进入时为True时, 立即返回. 否则, 阻塞直到其他线程调用set()方法将标准位设为True, 或者到达了可选的timeout时间.

  When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof).

  This method returns the internal flag on exit, so it will always return True except if a timeout is given and the operation times out.

  当给定了timeout参数且不为None, 它应该是一个浮点数，以秒为单位指定操作的超时（或是分数）。

  此方法在退出时返回内部标志，因此除非给定了超时且操作超时，否则它将始终返回True。

  Changed in version 2.7: Previously, the method always returned None.

  2.7版本以前, 这个方法总会返回None.

Using the blocking mechanism of wait, you can pause and resume, and then cooperate with the loop judgment Flag bit, you can exit. The following is a code example:

#!/usr/bin/env python
# coding: utf-8

import threading
import time

class Job(threading.Thread):

  def __init__(self, *args, **kwargs):
    super(Job, self).__init__(*args, **kwargs)
    self.__flag = threading.Event()   # 用于暂停线程的标识
    self.__flag.set()    # 设置为True
    self.__running = threading.Event()   # 用于停止线程的标识
    self.__running.set()   # 将running设置为True

  def run(self):
    while self.__running.isSet():
      self.__flag.wait()   # 为True时立即返回, 为False时阻塞直到内部的标识位为True后返回
      print time.time()
      time.sleep(1)

  def pause(self):
    self.__flag.clear()   # 设置为False, 让线程阻塞

  def resume(self):
    self.__flag.set()  # 设置为True, 让线程停止阻塞

  def stop(self):
    self.__flag.set()    # 将线程从暂停状态恢复, 如何已经暂停的话
    self.__running.clear()    # 设置为False

The following is the test code:

a = Job()
a.start()
time.sleep(3)
a.pause()
time.sleep(3)
a.resume()
time.sleep(3)
a.pause()
time.sleep(2)
a.stop()

Test results:




This completes the functions of pausing, resuming and stopping. But there is a disadvantage: neither pausing nor stopping is instantaneous. , you must wait for the operation inside the run function to reach the flag judgment before it is effective. In other words, the operation will be delayed once.

But this is not necessarily a bad thing sometimes. If the run function involves file operations or database operations Wait, run it completely and then exit. Instead, you can execute the remaining resource release operation code (such as various close). There will be no embarrassing situations such as the program's file operator exceeding the upper limit and the database connection not being released.

Thanks for reading, I hope it can help everyone, thank you for your support of this site!

The above is the detailed content of Detailed explanation of Python thread's pause, resume, and exit example code. For more information, please follow other related articles on the PHP Chinese website!