// 1. 使用 sync.Pool 复用对象
var bufPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

func process(data []byte) {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)
    buf.Reset()
    buf.Write(data)
    // 处理
}

// 2. 避免不必要的 goroutine
// ❌ 每个请求都创建 goroutine
for _, req := range requests {
    go handle(req) // 可能创建数千个 goroutine
}

// ✅ 使用 worker pool
sem := make(chan struct{}, 100)
for _, req := range requests {
    sem <- struct{}{}
    go func(r Request) {
        defer func() { <-sem }()
        handle(r)
    }(req)
}

// 3. 使用 context 传播取消
func fetchData(ctx context.Context) (Data, error) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()
    // ...
}

// 1. 使用连接池
const pool = new Pool({ max: 20 });

// 2. 使用 Promise.all 并发
// ❌ 串行
const a = await fetch('/api/a');
const b = await fetch('/api/b');

// ✅ 并发
const [a, b] = await Promise.all([
    fetch('/api/a'),
    fetch('/api/b'),
]);

// 3. 使用流处理大数据
// ❌ 一次性加载
const data = await readFile('large.csv');

// ✅ 流式处理
const stream = createReadStream('large.csv');
for await (const chunk of stream) {
    processChunk(chunk);
}

// 4. 避免阻塞事件循环
// ❌ CPU 密集型任务
function compute(n) { /* heavy computation */ }

// ✅ 使用 Worker Threads
const { Worker } = require('worker_threads');
const worker = new Worker('./compute.js', { workerData: n });

# 1. 使用 Semaphore 限制并发
sem = asyncio.Semaphore(100)
async def limited_fetch(url):
    async with sem:
        return await fetch(url)

# 2. 使用 gather 而非顺序 await
# ❌ 串行
a = await fetch_a()
b = await fetch_b()

# ✅ 并发
a, b = await asyncio.gather(fetch_a(), fetch_b())

# 3. 使用 uvloop 替代默认事件循环
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

# 4. 避免在 async 函数中调用阻塞函数
# ❌ 阻塞事件循环
await asyncio.sleep(0)
time.sleep(1)  # 阻塞！

# ✅ 使用 to_thread
await asyncio.to_thread(time.sleep, 1)

# CPU 分析
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 内存分析
go tool pprof http://localhost:6060/debug/pprof/heap

# goroutine 分析（检测泄漏）
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 竞态检测
go test -race ./...

# 启动调试模式
node --inspect=0.0.0.0:9229 src/index.js

# Clinic.js 性能分析
npx clinic doctor -- node src/index.js
npx clinic flame -- node src/index.js
npx clinic bubbleprof -- node src/index.js

// 1. 添加请求 ID 追踪
const { v4: uuidv4 } = require('uuid');

app.use((req, res, next) => {
    req.id = uuidv4();
    console.log(`[${req.id}] ${req.method} ${req.url}`);
    next();
});

// 2. 异步操作计时
async function timedOperation(name, fn) {
    const start = Date.now();
    try {
        const result = await fn();
        console.log(`[${name}] 完成，耗时 ${Date.now() - start}ms`);
        return result;
    } catch (err) {
        console.error(`[${name}] 失败，耗时 ${Date.now() - start}ms:`, err.message);
        throw err;
    }
}

// 3. 检测未处理的 Promise
process.on('unhandledRejection', (reason, promise) => {
    console.error('未处理的 Promise 拒绝:', reason);
    // 记录到监控系统
});

// ❌ 忘记 await，返回 Promise 而非结果
async function getUser(id) {
    return await db.query('SELECT * FROM users WHERE id = ?', [id]);
}

async function handler(req, res) {
    const user = getUser(req.params.id);  // user 是 Promise，不是用户数据！
    res.json(user);  // 发送的是 [object Promise]
}

// ✅ 始终 await
async function handler(req, res) {
    const user = await getUser(req.params.id);
    res.json(user);
}

// ❌ 无限制并发，可能压垮数据库
async function processAll(items) {
    await Promise.all(items.map(item => db.save(item)));  // 10000 个并发查询！
}

// ✅ 限制并发
import pLimit from 'p-limit';
const limit = pLimit(10);

async function processAll(items) {
    await Promise.all(items.map(item => limit(() => db.save(item))));
}

// ❌ 未关闭数据库连接
async function query(sql) {
    const conn = await pool.getConnection();
    const result = await conn.query(sql);
    // 如果上面抛异常，连接不会被释放！
    conn.release();
    return result;
}

// ✅ 使用 try/finally 或 with
async function query(sql) {
    const conn = await pool.getConnection();
    try {
        return await conn.query(sql);
    } finally {
        conn.release();
    }
}

// ❌ 异常被静默吞没
async function process() {
    backgroundTask();  // 如果抛异常，无人知晓
}

// ✅ 添加错误处理
async function process() {
    backgroundTask().catch(err => {
        console.error('后台任务失败:', err);
        logger.error(err);
    });
}

// ❌ 死锁：两个 goroutine 互相等待
func deadlock() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() { ch1 <- <-ch2 }()
    go func() { ch2 <- <-ch1 }()

    // 永远阻塞
}

// ✅ 使用 select 或 context 超时
func safeTransfer(ctx context.Context, ch1, ch2 chan int) {
    select {
    case ch1 <- <-ch2:
    case <-ctx.Done():
        return // 超时退出
    }
}

// ❌ goroutine 永远不会退出
func leakyFunction() chan int {
    ch := make(chan int)
    go func() {
        for {
            ch <- doWork()  // 如果没有消费者，goroutine 永远阻塞
        }
    }()
    return ch
}

// ✅ 使用 context 控制生命周期
func controlledFunction(ctx context.Context) chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        for {
            select {
            case ch <- doWork():
            case <-ctx.Done():
                return
            }
        }
    }()
    return ch
}