startup

启动速度直接影响用户体验，Claude Code 通过多种技术实现 < 1 秒的冷启动。

优化目标

• 冷启动: < 1 秒（首次运行）

• 热启动: < 300ms（后续运行）

• 首次交互: < 2 秒（到第一个 AI 响应）

多级 Fast-Path

1

Level 1: 最小化导入

// ❌ 启动时导入所有模块
import * as tools from './tools';
import * as services from './services';
import * as plugins from './plugins';

// ✅ 延迟导入
async function loadTools() {
  return await import('./tools');
}

2

Level 2: 并行预取

async function startup() {
  // 并行加载
  const [config, state, tools] = await Promise.all([
    loadConfig(),
    loadState(),
    loadTools(),
  ]);
  
  return { config, state, tools };
}

3

Level 3: 按需加载

// Skills 和 Plugins 按需加载
async function getSkills() {
  if (!skillsCache) {
    skillsCache = await loadSkills();
  }
  return skillsCache;
}

代码分割

动态导入

// 主入口只加载核心模块
async function main() {
  const { query } = await import('./query');
  const { tools } = await import('./tools');
  
  // 启动 UI
  await startUI(query, tools);
}

条件加载

// 只在需要时加载
if (options.enableBridge) {
  const { initBridge } = await import('./bridge');
  await initBridge();
}

if (options.enableMCP) {
  const { loadMCPServers } = await import('./services/mcp');
  await loadMCPServers();
}

缓存策略

配置缓存

let configCache: Config | null = null;

async function loadConfig(): Promise<Config> {
  if (configCache) {
    return configCache;
  }
  
  const config = await readConfigFile();
  configCache = config;
  
  return config;
}

System Prompt 缓存

const promptCache = new Map<string, string>();

async function getSystemPrompt(tools: Tool[]): Promise<string> {
  const key = hashTools(tools);
  
  if (promptCache.has(key)) {
    return promptCache.get(key);
  }
  
  const prompt = await buildSystemPrompt(tools);
  promptCache.set(key, prompt);
  
  return prompt;
}

避免同步 I/O

异步文件操作

// ❌ 同步读取（阻塞）
const config = JSON.parse(fs.readFileSync('config.json', 'utf-8'));

// ✅ 异步读取（非阻塞）
const config = JSON.parse(await fs.readFile('config.json', 'utf-8'));

并行 I/O

// ❌ 串行读取
const file1 = await fs.readFile('file1.txt');
const file2 = await fs.readFile('file2.txt');
const file3 = await fs.readFile('file3.txt');

// ✅ 并行读取
const [file1, file2, file3] = await Promise.all([
  fs.readFile('file1.txt'),
  fs.readFile('file2.txt'),
  fs.readFile('file3.txt'),
]);

预编译

Bun 构建

使用 Bun 预编译 TypeScript：

# 构建
bun build src/main.tsx --outdir dist --target node

# 启动预编译版本
node dist/main.js

优势

• 无需运行时转译

• 更快的启动速度

• 更小的内存占用

启动流程

优化后的流程

async function optimizedStartup() {
  const startTime = performance.now();
  
  // 1. 最小化初始化
  const coreModules = await import('./core');
  
  // 2. 并行预取
  const [config, state] = await Promise.all([
    loadConfig(),
    loadState(),
  ]);
  
  // 3. 启动 UI（不等待完整加载）
  startUI();
  
  // 4. 后台加载其他模块
  Promise.all([
    loadSkills(),
    loadPlugins(),
    connectMCPServers(),
  ]).then(() => {
    console.log('All modules loaded');
  });
  
  const duration = performance.now() - startTime;
  console.log(`Startup: ${duration}ms`);
}

性能测量

启动时间分析

const timings = {
  import: 0,
  config: 0,
  state: 0,
  ui: 0,
  total: 0,
};

async function measureStartup() {
  const start = performance.now();
  
  // 导入
  const t1 = performance.now();
  await import('./core');
  timings.import = performance.now() - t1;
  
  // 配置
  const t2 = performance.now();
  await loadConfig();
  timings.config = performance.now() - t2;
  
  // 状态
  const t3 = performance.now();
  await loadState();
  timings.state = performance.now() - t3;
  
  // UI
  const t4 = performance.now();
  await startUI();
  timings.ui = performance.now() - t4;
  
  timings.total = performance.now() - start;
  
  console.table(timings);
}

下一步

• 了解 流式工具执行 的并发机制

• 探索 缓存策略 的详细实现

• 查看 并发控制 的限制策略