服务性能测试

调试 Node 性能首先得找到性能瓶颈所在，包括两个方面：

1. top， 测试 CPU 和内存
2. iostat， io 设备的带宽（硬盘）

Node 性能分析工具

CPU 分析优化

工具

profile 探测器 + ab 压测

Node 自带的 profile

文档

1. 启动 node 程序，运行 node --prof server.js 会生成 log 文件
2. 压测 ab -c100 -t10 http://127.0.0.1:3000/dowload
3. 执行 log 文件：node --prof-process xxx.log > profile.txt

--inspect-brk 参数

要想在应用代码的第一行断开，可以传入 --inspect-brk 标志

1. 启动 node 程序 node --inspect-brk server.js
2. 打开 Chrome 的 inspect 切换到 Profiler，启动 CPU 监控
3. 压测
4. 暂停、分析结果

Heavy 模式

image.png

Chart 模式

image.png

clinic 工具

npm install clinic -g

根据性能分析报告优化程序

Javascript 代码性能优化

计算性能优化的本质

1. 减少不必要的计算
2. 空间换取时间

HTTP 服务性能优化准则

1. 提前计算（计算是否可以提前到服务启动阶段

   
   image.png

内存分析优化

GC
新生代，容量小，垃圾回收快
老生代，容量大，垃圾回收慢
减少内存使用，提高服务性能

不要出现内存泄露。

分析内存使用情况

--inspect-brk 调试

1. node --inspect-brk-server.js
2. 打开 chrome 控制面板，切到 Memory
3. 压测
4. 压测过程中抓取快照

为了便于直观的观察内存的占用，在请求中创建数组 生成 长度为 100w 的数组

压测：

ab -c100 -t10 http://127.0.0.1:3000/api/1000000

压测（请求）过程中抓取的快照 内存占用（318M）

image.png

压测（请求）结束后抓取的快照 内存占用（7.7M）

image.png

比较两次快照

image.png

制造内存泄漏的场景

创建不被释放的数组，每次请求往数组中添加元素

压测前后的内存使用情况

image.png

都是没有释放的数组，还指出了变量名，执行栈（函数）

image.png

优化内存

1. Buffer 分配内存

2. 自己编写 c++插件

3. 子进程与线程

   • 进程
   • 操作系统挂载运行程序的单元
   • 拥有独立的资源，比如内存
   • 线程
   • 进行运算调度的单元
   • 进程内的线程共享进程内的资源

4. Node 子进程和线程

   • 主线程运行 V8 和 js
   • 多个子线程通过事件循环被调度
   • 使用子进程或线程利用更多的 CPU 资源

5. 集群模式

   • 集群模式可以监听相同的端口
   • lib > net.js > listenInCluster 方法

child_process

// worker.js
const http = require('http')
const port = Math.round((Math.random() + 1) * 1000)

http
  .createServer((req, res) => {
    res.end(port + '')
  })
  .listen(port, () => {
    console.log('runing: ', port)
  })

process.on('message', data => {
  console.log('child', port, data)
  process.send('from child --- ' + port)
})

// master.js
const os = require('os')
const { fork } = require('child_process')
const cpus = os.cpus().length

const createWorker = () => {
  const child_process = fork(__dirname + '/worker.js') // ChildProcess 的实例，其实还是发布订阅模式 基于 Event 事件实现的

  // 向子进程发送消息
  child_process.send('from master!')

  // 监听子进程消息
  child_process.on('message', data => {
    console.log('from child, port is --- ', data)
  })

  // 子进程退出时重启
  child_process.on('exit', () => {
    console.log('child_process is died --- ' + child_process.pid)
    createWorker()
  })

  // 子进程无法被复制创建、杀死、发送消息时触发
  child_process.on('error', () => {
    console.log('')
  })
}

for (let i = 0; i < cpus; i++) {
  createWorker()
}

// 创建子进程后主进程没有退出，如果和子进程没有事件回调交互的话需要手动退出主进程。所以这就是为什么一般根据cpu核数创建子进程，因为子进程开启后主进程退出了。
// setTimeout(() => {
//   process.exit(1)
// }, 2000)

cluster

// app.js
const http = require('http')

http
  .createServer((req, res) => {
    res.writeHead(200)
    res.end('hello world')
  })
  .listen(8000)

process.on('message', msg => {
  if (msg === 'ping') {
    process.send('pang')
  }
})

// 处理没有捕获到的错误
process.on('uncaughtException', err => {
  console.error(err)
  process.exit(1)
})

// 监听内存泄漏
setInterval(() => {
  if (process.memoryUsage.memoryUsage().rss > 700 * 1024 * 1024) {
    console.log('memory leak')
    process.exit(1)
  }
}, 5000)

// index.js
const cluster = require('cluster')
const process = require('process')
const cpus = require('os').cpus().length

const createWorker = () => {
  let count = 0
  const worker = cluster.fork()

  // 监听子进程是否还在工作
  setInterval(() => {
    worker.send('ping')
    count++

    if (count > 3) {
      worker.exit(1)
    }
  }, 3000)

  worker.on('message', msg => {
    if (msg === 'pang') {
      count--
    }
  })
}

if (cluster.isPrimary) {
  console.log(`Primary ${process.pid} is running`)

  // Fork workers
  for (let i = 0; i < cpus / 2; i++) {
    createWorker()
  }

  // 监听子进程状态
  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid} died`)

    setTimeout(() => {
      createWorker()
    }, 5000)
  })
} else {
  require('./app')
}

架构优化

动静分离

静态内容

Q：基本不会变动，也不会因为请求参数的不同而变化的
A： 使用 CDN 分发，HTTP 缓存

动态内容

Q：各种因为请求参数不同而变动，且变动的数量几乎不可枚举
A：用大量的源站机器承载，结合反响代理进行负载均衡

反向代理和缓存服务

Nginx 反向代理
redis 缓存