异步 on PlumePHP

Python 高级异步编程：Trio 结构化并发与 AnyIO 兼容层

Tue, 18 Aug 2026 12:00:00 +0800

1. asyncio 的局限与痛点

asyncio 是 Python 标准库中的异步编程框架，自 Python 3.4 引入以来已经发展成熟。然而，在生产环境和高并发场景下，asyncio 暴露出一系列设计上的缺陷：

Node.js 异步编程与并发模型

Sat, 15 Aug 2026 10:00:00 +0800

1. Event Loop 详解

1.1 事件循环阶段

 ┌───────────────────────────┐
┌─>│ timers │ ← setTimeout/setInterval
│ └─────────────┬─────────────┘
│ ┌─────────────▼─────────────┐
│ │ pending callbacks │ ← I/O callbacks deferred
│ └─────────────┬─────────────┘
│ ┌─────────────▼─────────────┐
│ │ idle, prepare │ ← internal
│ └─────────────┬─────────────┘
│ ┌─────────────▼─────────────┐
│ │ poll │ ← retrieve new I/O events
│ │ (阻塞等待 I/O) │
│ └─────────────┬─────────────┘
│ ┌─────────────▼─────────────┐
│ │ check │ ← setImmediate
│ └─────────────┬─────────────┘
│ ┌─────────────▼─────────────┐
│ │ close callbacks │ ← socket.on('close')
│ └───────────────────────────┘
│
└─────────────────────────────────┘
 每次循环 = 一个 tick
 microtask 队列（process.nextTick / Promise）在每阶段后执行

1.2 执行顺序示例

console.log('1');

setTimeout(() => console.log('2'), 0);
setImmediate(() => console.log('3'));

Promise.resolve().then(() => console.log('4'));
process.nextTick(() => console.log('5'));

console.log('6');

// 输出: 1, 6, 5, 4, 2, 3
// 解释:
// 1. 同步代码: 1, 6
// 2. nextTick: 5
// 3. Promise microtask: 4
// 4. timers: 2 (setTimeout)
// 5. check: 3 (setImmediate)
// 注意: setTimeout(0) 和 setImmediate 顺序取决于 poll 阶段是否有 I/O

1.3 阻塞 Event Loop 的危险

// ❌ 同步计算阻塞（CPU 密集型）
app.get('/fib/:n', (req, res) => {
 const n = parseInt(req.params.n);
 const result = fibonacci(n); // 同步递归，阻塞事件循环！
 res.json({ result });
});

// ✅ 方案 1：拆分计算（setImmediate）
function fibAsync(n, callback) {
 let a = 0, b = 1;
 function step() {
 if (n <= 0) return callback(a);
 [a, b] = [b, a + b];
 n--;
 setImmediate(step); // 让出事件循环
 }
 step();
}

// ✅ 方案 2：Worker Threads
const { Worker } = require('worker_threads');
app.get('/fib/:n', async (req, res) => {
 const worker = new Worker('./fib-worker.js', {
 workerData: parseInt(req.params.n)
 });
 worker.on('message', result => res.json({ result }));
});

2. Worker Threads

Node.js 10.5+ 引入 Worker Threads，实现了真正的多线程并行计算。

Python 异步任务队列：Celery + Redis/RabbitMQ 实战

Sat, 15 Aug 2026 10:00:00 +0800

1. Celery 架构

Application
 ├── Producer（Flask/Django/FastAPI）──→ 发送任务
 │
 ├── Broker（Redis / RabbitMQ）───────→ 任务队列存储
 │
 ├── Worker（多进程/多线程）────────→ 消费并执行任务
 │
 └── Backend（Redis / Database）────→ 存储任务结果

2. 快速上手

from celery import Celery

# 创建 Celery 应用
app = Celery('tasks',
 broker='redis://localhost:6379/0',
 backend='redis://localhost:6379/1'
)

# 定义任务
@app.task(bind=True, max_retries=3)
def send_email(self, to: str, subject: str, body: str):
 """发送邮件任务"""
 try:
 smtp.send(to, subject, body)
 return {"status": "sent", "to": to}
 except Exception as exc:
 # 指数退避重试
 raise self.retry(exc=exc, countdown=2 ** self.request.retries)

@app.task
def process_image(image_path: str):
 """处理图片任务"""
 from PIL import Image
 img = Image.open(image_path)
 img.thumbnail((800, 600))
 img.save(image_path + '.thumb.jpg')
 return {"thumbnail": image_path + '.thumb.jpg'}

# 定时任务
@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
 sender.add_periodic_task(60.0, cleanup.s(), name='cleanup every minute')
 sender.add_periodic_task(crontab(hour=2, minute=0), backup.s())

3. 调用任务

# 异步调用（立即返回.AsyncResult）
result = send_email.delay('user@example.com', 'Hello', 'Welcome!')
print(result.id) # 获取任务 ID

# 查询结果
result = send_email.AsyncResult(result.id)
if result.ready():
 print(result.get(timeout=10)) # 获取结果

# 定时执行
send_email.apply_async(
 args=['user@example.com', 'Hello', 'Welcome!'],
 countdown=300, # 5 分钟后执行
 eta=datetime(2024, 1, 1, 10, 0), # 指定时间
 queue='email' # 指定队列
)

4. 生产配置

# celeryconfig.py
broker_url = 'amqp://user:password@rabbitmq:5672/myvhost'
result_backend = 'redis://redis:6379/0'

# 序列化
task_serializer = 'json'
result_serializer = 'json'
accept_content = ['json']

# Worker 配置
worker_prefetch_multiplier = 1 # 一次只取一个任务
worker_max_tasks_per_child = 1000 # 执行 N 个任务后重启 Worker

# 任务结果过期时间
result_expires = 3600 # 1 小时

# 路由
task_routes = {
 'tasks.send_email': {'queue': 'email'},
 'tasks.process_image': {'queue': 'image'},
}

# 队列定义
task_queues = (
 Queue('default', routing_key='default'),
 Queue('email', routing_key='email'),
 Queue('image', routing_key='image'),
)

5. 监控与运维

# 启动 Worker
celery -A tasks worker --loglevel=info --queues=default,email,image -c 4

# 启动 Beat（定时任务调度）
celery -A tasks beat --loglevel=info

# Flower 监控界面
celery -A tasks flower --port=5555
# 访问 http://localhost:5555 查看任务状态、Worker 负载、队列深度

异步 on PlumePHP

Python 高级异步编程：Trio 结构化并发与 AnyIO 兼容层

1. asyncio 的局限与痛点

Node.js 异步编程与并发模型

1. Event Loop 详解

1.1 事件循环阶段

1.2 执行顺序示例

1.3 阻塞 Event Loop 的危险

2. Worker Threads

Python 异步任务队列：Celery + Redis/RabbitMQ 实战

1. Celery 架构

2. 快速上手

3. 调用任务

4. 生产配置

5. 监控与运维

延伸阅读