[python 일반] How to Run a Periodic Background Task in Python

You can run a periodic task in the background via a daemon thread.

In this tutorial you will discover how to run a periodic task in the background in Python.

Let’s get started.

Need for a Periodic Background Task

A thread is a thread of execution in a computer program.

Every Python program has at least one thread of execution called the main thread. Both processes and threads are created and managed by the underlying operating system.

Sometimes we may need to create additional threads in our program in order to execute code concurrently.

Python provides the ability to create and manage new threads via the threading module and the threading.Thread class.

You can learn more about Python threads in the guude:

• Threading in Python: The Complete Guide

In concurrent programming, we may need to run a task periodically in the background.

This may be for many reasons, such as:

• Reloading or refreshing data in the application.
• Storing or saving data from the application.
• Reporting or logging progress of the application.

Periodically means that the task is repeated after a consistent time interval, such as:

• Every few seconds.
• Every few minutes.
• Every few hours.

Background means that the task is not the main purpose of the application, but instead is a task that supports the main application.

How can we run a periodic task in the background in Python?

How to Create a Periodic Background Task

You can run a periodic task in the background using a daemon thread with a while loop and a sleep.

A daemon thread is a background thread. Daemon is pronounced “dee-mon“, like the alternate spelling “demon“.

A thread may be configured to be a daemon or not, and most threads in concurrent programming, including the main thread, are non-daemon threads (not background threads) by default. The difference between daemon threads and non-daemon threads is that the process will exit if only daemon threads are running, whereas it cannot exit if at least one non-daemon thread is running.

As such, daemon threads are helpful for executing tasks in the background to support the non-daemon threads in an application.

If you are new to daemon threads, you can learn more about them here:

• How to Use Daemon Threads in Python

A Python threading.Thread instance can be configured to be a daemon thread.

We can configure a new thread to be a daemon thread by specifying the “daemon” argument to True in the constructor of the threading.Thread class.

For example:

We can configure a new daemon thread to execute a custom function that will execute a program specific task periodically.

For example we might define a new function named background_task() that takes an integer argument in seconds.

Then configure a new threading.Thread instance to execute this function via the “target” keyword and pass an argument to the function via the “args” argument. The thread can be made daemon via the “daemon” argument and the thread can be given a meaningful name via the “name” argument.

Periodically means repeatedly after the same time interval for as long as the program is running.

This can be achieved with a while-loop that will execute our desired task each interval and sleep for a configured number of seconds.

For example:

Because the thread executing our task is a daemon thread, it will not prevent the program from exiting once the tasks of the main thread are finished.

Now that we know how to run a periodic task in the background, let’s look at a worked example.

Example of a Periodic Background Task

We can explore how to run a periodic background task in a daemon thread.

In this example, we will define a new function that will execute our task every few seconds. This new task will be started in the main thread and run in the background while the main thread proceeds with its own tasks.

Firstly, we can define a new function named background_task() that will execute our background task.

The function will take one argument which is the interval in seconds between each execution of the task.

We can then create a while-loop that will run for the duration of the program.

Each iteration of the loop, the function will execute a custom background task and sleep for the configured interval. The order of the task execution and sleep does not matter and may be specific to your application, although a sleep first ensures an initial delay before the first execution of the task.

This may be desirable as it gives the main thread a chance to start running.

In this case, our periodic task will be to simply report a message, but it may be any application specific task you like.

Tying this together, the complete background_task() function for executing our periodic background task is listed below.

Next, we can create a new threading.Thread instance and configure it to execute our background task function.

The name of the function can be specified via the “target” argument and the time interval can be passed via the “args” argument. We can also configure the thread to be a daemon background thread via the “daemon” argument and give the thread a meaningful name via the “name” argument.

We will configure the background task to run (about) every three seconds. We don’t have fine grained control over when the thread will run exactly, but it is close enough.

Once defined, the new background thread can be started.

Next, the main thread can carry on with the normal execution of the program.

We can simulate this with a sleep for ten seconds, allowing the background task to run a few times.

Finally, the main thread will finish its main task (of sleeping), and terminate. This will terminate the application as the background thread is a daemon thread and will be terminated automatically by the process.

Tying this together, the complete example is listed below.

Running the example first creates and starts the daemon thread.

This runs our while-loop in our custom background task function. Each iteration of the loop, the thread will sleep for three seconds then report a message for the life-time of the program.

The main thread then carries on as per normal.

After ten seconds, the main thread wakes up, and terminates, terminating the entire program including the running daemon thread in the background.

Note, daemon threads are terminated abruptly and you may need to pay special attention to the handling of any open resources, like files and socket connections.

 

[출처] https://superfastpython.com/thread-periodic-background/