Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Timeout control related to Python threads and a simple application     - Android Notification (Programming)

- Log in CentOS 6.5 Multi-user setting VNC (Server)

- HomeKit Human Interface Guidelines (Linux)

- JDK comes with tools JPS (Linux)

- Online booking shocking information leakage risk, you dare book the tickets online? (Linux)

- Python 3.5 await / async (Programming)

- Bash mathematical extension (Programming)

- Linux Getting Started tutorial: XWindow what (Linux)

- Install Git on CentOS (Linux)

- Oracle to use full-text indexing (Database)

- Linux System Getting Started Learning: rename multiple files in Linux (Linux)

- Some problems and countermeasures Linux system calls exist (Linux)

- Oracle table space usage monitoring (Database)

- Fedora 20 users install the Mate 1.8 desktop (Linux)

- Ubuntu set Swap Space Tutorial (Linux)

- CV: Linux command displays the progress of the run command (Linux)

- Use smartmontools view the health status of hard disk (Linux)

- High-performance JavaScript DOM programming (Programming)

- Ubuntu 14.04 install the NVIDIA driver + CUDA + MATLAB (Linux)

- Flask installation environment (Linux)

 
         
  Timeout control related to Python threads and a simple application
     
  Add Date : 2018-11-21      
         
         
         
  First, a brief introduction

Thread timeout control in practical applications is certainly widespread, such as network connection timeout (socket), document processing timeouts, etc., but now looks like a programming language are not a good deal timeout mechanisms to achieve management (and possibly I am ignorant, brethren wish to know under the wing, grateful!), the general argument is not deliberately to kill a thread from the outside, the proper way to exit a thread is to thread run () method or if the end of the run run () method is an option to set a loop variable in the run () method which controls the loop termination condition (actually let run () "natural death"). Methods Some programming languages, such as Python, in which multi-threaded mechanism, such as threading.Thread, did not provide termination of threads (http://docs.python.org/library/threading.html#thread-objects).

So how do we make the timeout thread exits it, or how to implement timeouts management? In fact, it takes a little strategy.

Before saying this thing, at first understand how to write in python inside multi-threaded program that lets you inherit threading.Thread class, and the class __init __ () method which is called first threading.Thread the __init __ () method, and your class must have a no-argument run () method, as in the following example:

#! / Usr / bin / python
# - * - Coding: utf-8 - * -
import threading
################################################## ######################
class MyThread (threading.Thread):
    "" "A simple threading class." ""
    # ------------------------------------------------- ---------------------
    def __init __ (self):
        "" "Constructor" ""
        threading.Thread .__ init __ (self, name = "Thread-1")
        
    # ------------------------------------------------- ---------------------
    def run (self):
        "" "The working method, put all the work of the class in it." ""
        print "I am a threading class, my name is:% s"% self.getName ()
        print "I am stopping ..."
        
mythread = MyThread ()
mythread.start ()

Two, Python provides thread timeout detection mechanism

Thread timeout or not you can use to provide their own mechanism to detect Python, this is the thread's join () function, in the document which python can find detailed descriptions of the function (http://docs.python.org/library/threading .html # threading.Thread.join). Simply put, if two threads simultaneously executed t1 and t2, if you want a thread to wait for another thread of execution before the end of the execution, then you must do is to wait for the thread join () method, the code examples are as follows:

# ------------------------------------------------- ---------------------
def test ():
    "" "A task control function." ""
    ... # Previous job
    t1 = Thread1 ()
    t2 = Thread2 ()
    t1.start ()
    t2.start ()
    t2.join (10) # wait here until t2 is over or timeout occured (10 seconds)
    ... # The next job

Through the above link to find join () method of the document can be known, this method has an optional parameter timeout, if, as the above example this parameter is set, then the function will be performed in this thread waits for t2 10 seconds during this period the caller (caller) do nothing, just wait until the end of t2 or overtime, and will execute the following code. If you do not set the timeout parameters, caller will wait here until the end of t2 run. It should be noted that, join () function here only acts as a "sampling", which does not terminate execution t2 in overtime when, in fact t2 in the case of a timeout would be executed until it ends or another case, caller over, but the premise is t2 must be set to "daemon thread (daemon)".

We just know where to wait for a specific time and then execute the following code, then how do we judge whether t2 is executed or the end of a timeout thread of it? This thread needs to know the concept of "active (alive)" of. In general, a thread since the start () method is called the beginning until the run () function returns the period are considered to be active, but also provides a method for python isAlive () to determine whether the thread is active. Yes, exactly, if timed out, then, isAlive () method certainly return True (because the join () method is not the end of the thread, the thread is still active), and if the implementation of the end, run () function must have Back, then isAlive () method certainly return False. Code examples are as follows:

# ------------------------------------------------- ---------------------
def test ():
    "" "A task control function." ""
    ... # Previous job
    t1 = Thread1 ()
    t2 = Thread2 ()
    t1.start ()
    t2.start ()
    t2.join (10) # wait here until t2 is over or timeout occured (10 seconds)
    if t2.isAlive (): # if t2 is still alive, then it is time out!
 print 't2 is time out!'
    ... # The next job

Third, application examples

Timeouts and python basic time-out processing in the above has been given for the reader, in this section I will describe a simple example of a time-out control and management. In this example, I will have 10 special forces team to perform the task of the assassination of terrorists, everyone has their own assassination target, your goals must kill considered bin! Everyone time to perform the task is certainly not the same, but the helicopter retreated only waiting for a specific time to take off, which means that surely someone can not retreat because of a timeout, timeout people perform task failed!

Class 1: Soldier, mission class. There are two parameters in this class which has played a vital role and that is isStopped isSuccess, which indicates that this class is the implementation of the end, which illustrate the class is executed successfully. In addition, isStopped is also used to determine whether this class is a timeout, I'm not here said earlier isAlive () function to determine, because the isAlive () function of time is too strict, and I need to make a class set up their own whether to stop mark (class I've seen has been running over, but isAlive () function returns True or case). Every Soldier class call setDaemon (True) method is set to daemon thread (daemon), so-called daemon threads, that is, in the case where the caller is finished, the thread will end, otherwise the thread will continue until its real execution End. Soldier classes are as follows:

#! / Usr / bin / python
# - * - Coding: utf-8 - * -
import os, sys, re, math
import threading
import time
import random
################################################## ######################
class Soldier (threading.Thread):
    "" "The class of a soldier." ""
    # ------------------------------------------------- ---------------------
    def __init __ (self, name):
 "" "Constructor" ""
 threading.Thread .__ init __ (self, name = name)
 self.name = name # the name of this soldier
 self.setDaemon (True) # this is a daemon thread.
 
 # The time of this soldier need to finish the job
 self.playTime = random.randint (1,10)
 
 # Is the soldier stop shotting, if timeout or the target has been killed,
 # I may stop.
 self.isStopped = False
 self.isSuccess = False # did he kill the target?
    # ------------------------------------------------- ---------------------
    def assassinate (self):
 "" "The task, to kill the target." ""
 for i in range (self.playTime):
    print '% s play (% d)'% (self.name, i + 1)
    time.sleep (1)
 
    # ------------------------------------------------- ---------------------
    def run (self):
 "" "Start to move ..." ""
 print '% s has moved out, need time:% d ...'% (self.name, self.playTime)
 self.assassinate ()
 print '% s stopped ...'% self.name
 self.isStopped = True # the target has been killed, then he stopped.
 self.isSuccess = True

Class 2: Commander, Command Soldier class. This class is not to increase the dramatic effect and deliberately added, but this class is a must. Class mission requires a center for the caller to call join () method to determine whether a timeout. Yes caller can also call the turn when the workers begin their classes join () method to determine the timeout, but then, every call to join () are required to wait the equivalent of thread is not performed together but one by one performed. Therefore, the design of a middle class calls for each worker class is a must, caller calls in turn starts the middle class, so these classes run together, then all of the workers in the class is working together, this is a multi-threaded. Commander class as follows:

################################################## ######################
class Commander (threading.Thread):
    "" "The class of commander, a commander will command only one soldier." ""
    
    # ------------------------------------------------- ---------------------
    def __init __ (self, soldier):
 "" "Constructor" ""
 threading.Thread .__ init __ (self, name = 'Commander')
 self.soldier = soldier
 
    # ------------------------------------------------- ---------------------
    def run (self):
 "" "Authorize the soldier to start killing." ""
 self.soldier.start ()
 try:
    # Boss said: give the soldier 5 seconds to finish his job
    self.soldier.join (5)
 except:
    pass
 
 # Use the class's own attribute to judge whether it is timeout.
 #if self.soldier.isAlive ():
 if not self.soldier.isStopped:
    print '% s is timeout!'% self.soldier.name
    
    # The soldier run out his time, then he stopped.
    self.soldier.isStopped = True

Caller: perform all the work, including the initialization workers and the middle class call the class to the specified time to perform inspection results, etc., caller code is as follows:

# ------------------------------------------------- ---------------------
def killing ():
    "" "Let's pull the trigger, start killing!" ""
    t1 = time.time ()
    
    # Get ready for the commanders
    l_commander = []
    for i in range (10): # 10 soldiers
 # Get ready for the soldier
 soldier = Soldier (% 'soldier-% d' (i + 1))
 if i == 5 or i == 9:
    soldier.playTime = 10000
    
 l_commander.append (Commander (soldier))
    # Soldiers move out one by one.
    for cmd in l_commander:
 cmd.start ()
    # Judge whether the helicopter should go. If all the soldiers are stop,
    # That is, all finished job or timeout, then it should go!
    isBreak = False
    while not isBreak:
 isBreak = True
 for cmd in l_commander:
    if cmd.soldier.isStopped == False:
  isBreak = False
    # Check the results of the battle at the schedule time.
    for cmd in l_commander:
 print '% s, is success:% s'% (cmd.soldier.name, cmd.soldier.isSuccess)
    # Go back to base.
    time.sleep (20)
    
    # Check the results at the final time.
    for cmd in l_commander:
 print '% s, is success:% s'% (cmd.soldier.name, cmd.soldier.isSuccess)
 
    t2 = time.time ()
    print 'Total time:% .2f'% (float (t2-t1))

In the caller, use a while loop to wait for all the threads stop control without executing the following code, once all the threads stop, and check the result.

Executive killing () function has the following results:

soldier-1 has moved out, need time: 2 ...
soldier-1 play (1)
soldier-2 has moved out, need time: 6 ...
soldier-2 play (1)
soldier-3 has moved out, need time: 3 ...
soldier-3 play (1)
soldier-4 has moved out, need time: 4 ...
soldier-4 play (1)
soldier-5 has moved out, need time: 9 ...
soldier-5 play (1)
soldier-6 has moved out, need time: 10000 ...
soldier-6 play (1)
soldier-7 has moved out, need time: 8 ...
soldier-7 play (1)
soldier-8 has moved out, need time: 10 ...
soldier-8 play (1)
soldier-9 has moved out, need time: 7 ...
soldier-9 play (1)
soldier-10 has moved out, need time: 10000 ...
soldier-10 play (1)
soldier-3 play (2)
soldier-2 play (2)
soldier-4 play (2)
soldier-1 play (2)
soldier-6 play (2)
soldier-7 play (2)
soldier-5 play (2)
soldier-8 play (2)
soldier-9 play (2)
soldier-10 play (2)
soldier-1 stopped ...
soldier-3 play (3)
soldier-2 play (3)
soldier-7 play (3)
soldier-6 play (3)
soldier-5 play (3)
soldier-4 play (3)
soldier-8 play (3)
soldier-9 play (3)
soldier-10 play (3)
soldier-7 play (4)
soldier-6 play (4)
soldier-3 stopped ...
soldier-4 play (4)
soldier-2 play (4)
soldier-8 play (4)
soldier-5 play (4)
soldier-9 play (4)
soldier-10 play (4)
soldier-7 play (5)
soldier-6 play (5)
soldier-4 stopped ...
soldier-2 play (5)
soldier-8 play (5)
soldier-5 play (5)
soldier-9 play (5)
soldier-10 play (5)
soldier-6 is timeout!
soldier-2 is timeout!
soldier-7 is timeout!
soldier-8 is timeout!
soldier-5 is timeout!
soldier-7 play (6)
soldier-6 play (6)
soldier-2 play (6)
soldier-8 play (6)
soldier-5 play (6)
soldier-9 is timeout!
soldier-9 play (6)
soldier-10 is timeout!
soldier-1, is success: True
soldier-2, is success: False
soldier-3, is success: True
soldier-4, is success: True
soldier-5, is success: False
soldier-6, is success: False
soldier-7, is success: False
soldier-8, is success: False
soldier-9, is success: False
soldier-10, is success: False
soldier-10 play (6)
soldier-7 play (7)
soldier-6 play (7)
soldier-2 stopped ...
soldier-8 play (7)
soldier-5 play (7)
soldier-9 play (7)
soldier-10 play (7)
soldier-7 play (8)
soldier-6 play (8)
soldier-8 play (8)
soldier-5 play (8)
soldier-9 stopped ...
soldier-10 play (8)
soldier-7 stopped ...
soldier-6 play (9)
soldier-8 play (9)
soldier-5 play (9)
soldier-10 play (9)
soldier-6 play (10)
soldier-5 stopped ...
soldier-8 play (10)
soldier-10 play (10)
soldier-6 play (11)
soldier-8 stopped ...
soldier-10 play (11)
soldier-6 play (12)
soldier-10 play (12)
soldier-6 play (13)
soldier-10 play (13)
soldier-6 play (14)
soldier-10 play (14)
soldier-6 play (15)
soldier-10 play (15)
soldier-6 play (16)
soldier-10 play (16)
soldier-6 play (17)
soldier-10 play (17)
soldier-6 play (18)
soldier-10 play (18)
soldier-6 play (19)
soldier-10 play (19)
soldier-6 play (20)
soldier-10 play (20)
soldier-6 play (21)
soldier-10 play (21)
soldier-6 play (22)
soldier-10 play (22)
soldier-6 play (23)
soldier-10 play (23)
soldier-6 play (24)
soldier-10 play (24)
soldier-6 play (25)
soldier-10 play (25)
soldier-6 play (26)
soldier-1, is success: True
soldier-2, is success: True
soldier-3, is success: True
soldier-4, is success: True
soldier-5, is success: True
soldier-6, is success: False
soldier-7, is success: True
soldier-8, is success: True
soldier-9, is success: True
soldier-10, is success: False
Total time: 25.05

The results are displayed in 5 seconds, when the inspection results and only 1, 3 and 4 the successful completion of the task, the other out. Then, returning to the ground inside 20 seconds, the other unfinished threads did not stop, but continue to work after 20 seconds, caller has ended, note that all worker threads have been set to daemon thread , so when the end of the caller, also followed the end. The caller, in order to illustrate mission class to distinguish daemon thread and non-daemon threads, I have come to make 6 and 10 players time increases, so time at the end will be the end of the inspection victories, 6, and 10 did not complete , still out.

If the Soldier class self.setDaemon (True) commented, then 6 and 10 will continue to be run when the caller's end, which really run until the end of 10000 seconds later.

IV Summary

Timeout control and processing threads is a very useful technique, usually will use a lot. Using the detection method python itself providing and self-defined controls, we can achieve a good timeout control and management. In the case of the third part of this paper, I show a strategy of control of overtime that workers call the class + class + caller's model, each attribute which is the basis of this model inside and necessary. This model is currently being applied in my own project above, on this project, you need to use a lot of ways to deal with a computer proteins, each method is equivalent to the inside of the Soldier class examples in this article, a caller needs to give each method the results then were analyzed. In order to prevent the execution time of the whole system is a method of dragging long timeout control must be carried out for each of the processing method of the protein, which in a specified time if the method does not give results, automatically ignored.
     
         
         
         
  More:      
 
- Tab set to four spaces in Vim (Linux)
- SELinux security permissions HTTP + PHP service changes (Server)
- PF_RING 6.0.2 compiled and installed on Redhat 6.3 x86_64 (Linux)
- To install the Oracle 10.2.0.1.0 process notes on Oracle Linux 4u4 (Database)
- Git uses a standard process (Linux)
- Java List add duplicate the same object (Programming)
- How apt-get limited use IPv4 or IPv6 protocol to download (Linux)
- How to use Linux to download music from Grooveshark (Linux)
- Golang environment configuration recommendations (Linux)
- Ubuntu 14.04 installation configuration GNOME Classic interface (Linux)
- Safety testing Unix and Linux server entry succinctly (Linux)
- Bug tracking library after FastJson omitted the decimal point 0 (Programming)
- Build ftp server under CentOS 6.5 (Server)
- Hands to teach you to solve Ubuntu error message (Linux)
- CentOS 6.4 installation and configuration LNMP build PHP server runtime environment (Server)
- How do I delete a NEEDS RECOVERY rollback state of undo tablespace (Database)
- C # dynamic class notes --- (Dynamic) Applications (Programming)
- Spacewalk remove packages install the update (Linux)
- Linux operating system buffer overflow attacks Countermeasures (Linux)
- Xshell upload files to achieve Windows host Linux (Linux)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.