How to run two async functions forever in Python

Asynchronous functions, also known as coroutines, are functions that can be paused and resumed during execution. In Python, the asyncio module provides a powerful framework for writing concurrent code using coroutines, which are special functions that can be paused and resumed. In this article, we will explore how to run two asynchronous functions forever in Python using asyncio.

Asynchronous function

Asynchronous functions, also known as coroutines, are functions that can be paused and resumed during execution. They allow concurrent execution of code without blocking the main thread, enabling efficient use of system resources.

To define an asynchronous function in Python, we use the async keyword before the def statement. In an asynchronous function, we can use the await keyword to pause execution and wait for another asynchronous function or coroutine to complete.

Method 1-Use asyncio module

The asyncio module in Python provides a framework for writing single-threaded concurrent code using coroutines, multiplexing I/O access through sockets and other resources, running network clients and servers, and other related operations. It allows us to write asynchronous code in a structured and organized way.

grammar

Here, the asyncio.get_event_loop() function is used to retrieve the current event loop or create a new one if none exists.

Example

In the function1 example below, we have an infinite loop that prints "Function 1" and then pauses for 1 second using await asyncio.sleep(1). Likewise, function2 has an infinite loop that prints "Function 2" and pauses for 2 seconds. By calling asyncio.gather(function1(), function2()) in the main function, we instruct the event loop to execute both functions simultaneously. The asyncio.gather function is responsible for scheduling and running these two functions in an interleaved manner. When we run the Python script, the event loop runs indefinitely, repeatedly executing function1 and function2. The output demonstrates this behavior, with messages from both functions printed in an interleaved manner based on their respective time intervals.

import asyncio

async def function1():
    while True:
        print("Function 1")
        await asyncio.sleep(1)  # Pause execution for 1 second

async def function2():
    while True:
        print("Function 2")
        await asyncio.sleep(2)  # Pause execution for 2 seconds

async def main():
    await asyncio.gather(function1(), function2())

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    try:
        loop.run_until_complete(main())
    finally:
        loop.close()

Output

Function 1
Function 2
Function 1
Function 2
Function 1
Function 1
Function 2
Function 1
Function 1
.
.
.

Method 1-Using Threads

Threads are lightweight and allow multiple tasks to be executed concurrently in a single process. In this method, we will utilize the thread module to run two asynchronous functions forever.

grammar

thread1 = threading.Thread(target=async_function1)

Example

In the example below, we have two asynchronous functions: async_function1 and async_function2.

• async_function1 Use time.sleep(1) to print "Async function 1" every second.

• async_function2 uses time.sleep(2) to print "Async function 2" every two seconds.

We create two threads, thread1 and thread2, for async_function1 and async_function2 respectively. The Thread class in the thread module is used to create and manage threads. Then we start two threads using the start() method. This starts the execution of the asynchronous function in a separate thread, allowing them to run concurrently.

import threading
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

thread1 = threading.Thread(target=async_function1)
thread2 = threading.Thread(target=async_function2)

thread1.start()
thread2.start()

while True:
    pass

Output

The output of this example will continuously print "Async function 1" every second and "Async function 2" every two seconds. This code starts two threads, each executing its own asynchronous function. The main thread is kept alive through an infinite loop to allow other threads to run indefinitely.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

Method 3 - Using Subprocess

Subprocesses are independent processes that can be created and managed in Python programs. In this method, we will use the subprocess module to run two asynchronous functions forever.

grammar

subprocess.Popen(args, bufsize=-1, executable=None)

here,

• args (required): This parameter specifies the command to be executed. It can be a string or a sequence of strings.

• bufsize: This parameter indicates the buffer size used for I/O operations. The default value is -1, which means use the system default buffer size.

• bufsize: This parameter indicates the buffer size used for I/O operations. The default value is -1, which means use the system default buffer size.

Example

In this example, we have two identical async functions: async_function1 and async_function2.

• async_function1 Use time.sleep(1) to print "Async function 1" every second.

• async_function2 uses time.sleep(2) to print "Async function 2" every two seconds.

We use the subprocess.Popen class in the subprocess module to create subprocesses instead of threads. Each child process is created by executing a separate Python process that runs the corresponding asynchronous function. The subprocess is created using the subprocess.Popen constructor and we pass the Python command to execute the required function. For example, ['python', '-c', 'from module import async_function1; async_function1()'] runs async_function1 from a separate Python process.

import subprocess
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

subprocess1 = subprocess.Popen(['python', '-c', 'from module import async_function1; async_function1()'])
subprocess2 = subprocess.Popen(['python', '-c', 'from module import async_function2; async_function2()'])

while True:
    pass

Output

The output of this example will continuously print "Async function 1" every second and "Async function 2" every two seconds. This code creates two child processes, each executing its own asynchronous function. The main process is kept alive via an infinite loop to allow child processes to run indefinitely.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

结论

在本文中，我们讨论了如何使用 Python 中的 asyncio 模块在 Python 中永久运行两个异步函数。使用 asyncio 进行异步编程为编写高性能和响应式 Python 应用程序开辟了新的可能性。通过利用异步函数和事件循环，您可以利用并发的力量并有效地管理多个任务。

The above is the detailed content of How to run two async functions forever in Python. For more information, please follow other related articles on the PHP Chinese website!