thread priority in Python time frequency

Question

I am using multiple threads in python.

One thread will run exactly after 1 minute frequency. Another will run after every 2 minutes. one more will run after 10 minutes.

first one and second one will suppose to start together every 2 minutes. But I want one of them to run first.

similarly at every 10 minutes all of them will run simultaneously together. But I am looking for 1th one to start first , 2nd one to start second and 3rd one to start last at the frequency of every 10 minutes.

so is it possible to have thread priority in case of multiple threads ?

Ahmed AEK · Answer 1 · 2021-12-17T16:28:21.083

1

no, there is no thread priority in python, you can however create mutiple threads and have them time.sleep(), and use a timer event to time your code execution on the other threads.

# this makes program execute after an interval
from time import time, sleep
def work_once(time_seconds):
    sleep(time_seconds) # run after time_seconds seconds.
    # thing to run after time_seconds.

# this makes program sleep in intervals
from time import time, sleep

def work_interval(time_seconds):
    while True:
        sleep(time_seconds - time() % time_seconds) # run every time_seconds seconds.
        # thing to run every time_seconds.

and have your main thread pass in the time as argument when instantiating your thread.

from threading import Thread
worker = Thread(work_interval,args=(2,))
worker.start()

edited Dec 17 '21 at 16:28

answered Dec 17 '21 at 14:11

Ahmed AEK

8,584
2
7
23

This is **not** a reliable technique to get equal cycles. `time.sleep` only guarantees to sleep **at least** `time_seconds`. For example, it can sleep for 1.2 minutes instead of 1. See https://stackoverflow.com/questions/1133857/how-accurate-is-pythons-time-sleep – Expurple Dec 17 '21 at 14:36
yes, but you cannot get a more accurate clock than that using a pc, i'd recommend using a microcontroller if timing is an critical as a few microseconds, also 1.2 instead of 1 is an exaggeration, it's mostly 60.3 instead of 60 seconds, unless you stall your cpu till you hit the mark. – Ahmed AEK Dec 17 '21 at 14:50

score 1 · Answer 2 · answered Dec 17 '21 at 14:15

Threads aren't really supposed to give you any guarantees about the order of execution. You have a couple of options to define it yourself:

Describe the sequence in the main thread

If you currently have something like

def target1():
    target1_start()
    target1_body()

def target2():
    target2_start()
    target2_body()

def main():
    thread1 = Thread(target=target1)
    thread2 = Thread(target=target2)

Change it to

def main():
    target1_start()
    thread1 = Thread(target=target1_body)
    target2_start()
    thread2 = Thread(target=target2_body)

Hack with global variables

def target1():
    nonlocal thread1_started
    target1_start()
    thread1_started = True
    target1_body()

def target2():
    nonlocal thread1_started
    while not thread1_started:
        time.sleep(0.1)
    target2_start()
    target2_body()

def main():
    thread1_started = False
    thread1 = Thread(target=target1)
    thread2 = Thread(target=target2)

But this is very ugly, I suggest using the first option if possible

thread priority in Python time frequency

2 Answers2

Describe the sequence in the main thread

Hack with global variables