python如何同时跑两个循环

在Python中同时运行两个循环的最佳方法是使用多线程、多进程或异步编程。 多线程可以在单个进程中并发运行多个线程，而多进程则可以在多个CPU核心上并行运行代码。异步编程则允许在执行一个任务的过程中不阻塞其他任务的执行。下面将详细描述多线程和多进程的方法，并附上示例代码。

一、使用多线程

多线程是指在一个进程中执行多个线程，每个线程都可以独立执行任务。Python的threading模块提供了创建和管理线程的功能。

创建并启动线程

import threading
import time
def loop1():
    for i in range(5):
        print(f"Loop 1 - Iteration {i}")
        time.sleep(1)
def loop2():
    for i in range(5):
        print(f"Loop 2 - Iteration {i}")
        time.sleep(1)
创建线程
thread1 = threading.Thread(target=loop1)
thread2 = threading.Thread(target=loop2)
启动线程
thread1.start()
thread2.start()
等待线程完成
thread1.join()
thread2.join()
print("Both loops have finished.")

在上面的代码中，我们创建了两个线程thread1和thread2，分别执行loop1和loop2函数。start()方法用于启动线程，join()方法用于等待线程完成。

线程同步

有时候多个线程需要共享数据或资源，这就需要线程同步。Python提供了多种同步机制，如锁（Lock）和条件变量（Condition）。

import threading
import time
lock = threading.Lock()
def loop1(shared_data):
    for i in range(5):
        with lock:
            shared_data.append(f"Loop 1 - Iteration {i}")
        time.sleep(1)
def loop2(shared_data):
    for i in range(5):
        with lock:
            shared_data.append(f"Loop 2 - Iteration {i}")
        time.sleep(1)
shared_data = []
创建线程
thread1 = threading.Thread(target=loop1, args=(shared_data,))
thread2 = threading.Thread(target=loop2, args=(shared_data,))
启动线程
thread1.start()
thread2.start()
等待线程完成
thread1.join()
thread2.join()
print("Shared data:", shared_data)

在上面的代码中，我们使用lock来确保线程安全地访问和修改shared_data。

二、使用多进程

多进程是指在多个进程中执行代码，每个进程都有独立的内存空间。Python的multiprocessing模块提供了创建和管理进程的功能。

创建并启动进程

import multiprocessing
import time
def loop1():
    for i in range(5):
        print(f"Loop 1 - Iteration {i}")
        time.sleep(1)
def loop2():
    for i in range(5):
        print(f"Loop 2 - Iteration {i}")
        time.sleep(1)
创建进程
process1 = multiprocessing.Process(target=loop1)
process2 = multiprocessing.Process(target=loop2)
启动进程
process1.start()
process2.start()
等待进程完成
process1.join()
process2.join()
print("Both loops have finished.")

在上面的代码中，我们创建了两个进程process1和process2，分别执行loop1和loop2函数。start()方法用于启动进程，join()方法用于等待进程完成。

进程间通信

有时候多个进程需要共享数据或资源，这就需要进程间通信。Python提供了多种进程间通信机制，如队列（Queue）和管道（Pipe）。

import multiprocessing
import time
def loop1(queue):
    for i in range(5):
        queue.put(f"Loop 1 - Iteration {i}")
        time.sleep(1)
def loop2(queue):
    for i in range(5):
        queue.put(f"Loop 2 - Iteration {i}")
        time.sleep(1)
queue = multiprocessing.Queue()
创建进程
process1 = multiprocessing.Process(target=loop1, args=(queue,))
process2 = multiprocessing.Process(target=loop2, args=(queue,))
启动进程
process1.start()
process2.start()
等待进程完成
process1.join()
process2.join()
获取队列数据
while not queue.empty():
    print(queue.get())

在上面的代码中，我们使用queue来在进程之间传递数据。

三、使用异步编程

异步编程允许在执行一个任务的过程中不阻塞其他任务的执行。Python的asyncio模块提供了异步编程的支持。

创建并运行异步任务

import asyncio
async def loop1():
    for i in range(5):
        print(f"Loop 1 - Iteration {i}")
        await asyncio.sleep(1)
async def loop2():
    for i in range(5):
        print(f"Loop 2 - Iteration {i}")
        await asyncio.sleep(1)
async def main():
    task1 = asyncio.create_task(loop1())
    task2 = asyncio.create_task(loop2())
    await task1
    await task2
asyncio.run(main())

在上面的代码中，我们使用async和await关键字定义了异步函数loop1和loop2，并使用asyncio.create_task创建异步任务。asyncio.run(main())用于运行异步任务。

异步IO

异步编程特别适用于IO密集型任务，如网络请求、文件读写等。下面是一个异步IO的示例：

import asyncio
import aiohttp
async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            data = await response.text()
            print(f"Fetched data from {url}")
async def main():
    url1 = "https://example.com"
    url2 = "https://example.org"
    task1 = asyncio.create_task(fetch_data(url1))
    task2 = asyncio.create_task(fetch_data(url2))
    await task1
    await task2
asyncio.run(main())