Python中同步与异步函数的并发执行：结合asyncio与threading

import asyncio
import threading
import time

def do_sync(number: int) -> int:
    # 模拟一个耗时的同步阻塞操作
    print(f"同步函数 do_sync({number}) 在线程 {threading.current_thread().name} 中开始执行...")
    time.sleep(2) # 模拟2秒的阻塞
    result = number + 10
    print(f"同步函数 do_sync({number}) 在线程 {threading.current_thread().name} 中完成，结果: {result}")
    return result

async def do_async(number: int) -> int:
    # 模拟一个耗时的异步非阻塞操作
    print(f"异步函数 do_async({number}) 在线程 {threading.current_thread().name} 中开始执行...")
    await asyncio.sleep(1) # 模拟1秒的非阻塞等待
    result = number + 10
    print(f"异步函数 do_async({number}) 在线程 {threading.current_thread().name} 中完成，结果: {result}")
    return result

async def main():
    start_time = time.time()
    # 这里的do_sync(1)是一个普通的函数调用，它会阻塞main函数的执行
    # 直到do_sync(1)完全执行完毕，await do_async(2)才会被调度
    sync_result = do_sync(1)
    async_result = await do_async(2)

    final_max = max(sync_result, async_result)
    print(f"最终结果 max({sync_result}, {async_result}): {final_max}")
    print(f"总耗时: {time.time() - start_time:.2f} 秒")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import threading
import time
import concurrent.futures # 导入concurrent.futures模块

def do_sync_blocking(number: int) -> int:
    print(f"同步函数 do_sync_blocking({number}) 在线程 {threading.current_thread().name} 中开始执行...")
    time.sleep(2) # 模拟2秒的阻塞I/O或CPU工作
    result = number + 10
    print(f"同步函数 do_sync_blocking({number}) 在线程 {threading.current_thread().name} 中完成，结果: {result}")
    return result

async def do_async_non_blocking(number: int) -> int:
    print(f"异步函数 do_async_non_blocking({number}) 在线程 {threading.current_thread().name} 中开始执行...")
    await asyncio.sleep(1) # 模拟1秒的非阻塞I/O等待
    result = number + 10
    print(f"异步函数 do_async_non_blocking({number}) 在线程 {threading.current_thread().name} 中完成，结果: {result}")
    return result

async def main_parallel():
    start_time = time.time()
    loop = asyncio.get_running_loop()

    # 将同步阻塞函数提交到默认的ThreadPoolExecutor中执行
    # 这会立即返回一个Future对象，而不会阻塞当前事件循环
    sync_task_future = loop.run_in_executor(None, do_sync_blocking, 1)

    # 异步函数可以直接调度到事件循环中
    async_task_coro = do_async_non_blocking(2)

    # 使用asyncio.gather并发等待这两个任务的结果
    # gather会等待所有传入的awaitable对象完成
    results = await asyncio.gather(sync_task_future, async_task_coro)

    sync_result, async_result = results
    final_max = max(sync_result, async_result)

    print(f"最终结果 max({sync_result}, {async_result}): {final_max}")
    print(f"总耗时: {time.time() - start_time:.2f} 秒")

if __name__ == "__main__":
    asyncio.run(main_parallel())

import threading

shared_data = []
data_lock = threading.Lock()

def do_sync_with_lock(number: int) -> int:
    with data_lock: # 使用with语句确保锁的正确获取和释放
        shared_data.append(f"Processing {number}")
        # ... 其他操作 ...
    return number + 10

# 在一个非asyncio线程中
# loop.call_soon_threadsafe(my_callback, arg1, arg2)