Rust异步运行时选Tokio还是async-std

折腾了好几天终于搞定了，核心其实不难，但有几个坑容易踩。把要点列出来，省得大家再走弯路。

先搞清楚原理

Rust的底层原理涉及类型推导。用代码演示比画图更直观：

import asyncio
import time

async def fetch_data(url: str, delay: float = 0.5) -> dict:
    await asyncio.sleep(delay)
    return {'url': url, 'status': 200, 'data': f'Response from {url}'}

async def process_batch(urls: list) -> list:
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return [r for r in results if not isinstance(r, Exception)]

async def main():
    urls = [f'https://api.example.com/page/{j}' for j in range(10)]
    start = time.time()
    results = await process_batch(urls)
    elapsed = time.time() - start
    print(f'处理 {len(results)} 个请求，耗时 {elapsed:.2f}s')

asyncio.run(main())

实际怎么用

在真实项目中用Rust，和教程里还是有区别的。主要是类型推导这块需要额外处理。完整代码如下：

from functools import lru_cache
import time

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.time()
result = fibonacci(35)
elapsed = time.time() - start
print(f'fib(35) = {result}, 耗时: {elapsed:.4f}s')
print(f'缓存信息: {fibonacci.cache_info()}')

# 装饰器模式
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f'{func.__name__} 耗时: {elapsed:.4f}s')
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.1)
    return 'done'

slow_function()

进阶一点的用法

如果对性能有要求，Rust可以做类型推导方面的优化。核心改动不大，但效果明显：

容易踩的坑

说几个容易踩的坑。第一个是类型推导的问题，很多人在这上面栽过跟头。第二个是版本兼容性，不同版本行为可能不一样。第三个是边界情况，空值和异常输入要处理好。

写在最后

总结一下，Rust的关键在于并发调度机制。掌握了这个，其他用法都是在这个基础上扩展。建议多写几个小demo练手，光看不动手容易忘。