整理自程序员成长指北--- Node.js必知必会系列

Node.js究竟是什么？

简单的说 Node.js 就是运行在服务端的 JavaScript。Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执行Javascript的速度非常快，性能非常好。

1.特点

1.1 非阻塞异步io

例如，当在访问数据库取得数据的时候，需要一段时间。在传统的单线程处理机制中，在执行了访问数据库代码之后，整个线程都将暂停下来，等待数据库返回结果，才能执行后面的代码。也就是说，I/O阻塞了代码的执行，极大地降低了程序的执行效率。
由于 Node.js 中采用了非阻塞型I/O机制，因此在执行了访问数据库的代码之后，将立即转而执行其后面的代码，把数据库返回结果的处理代码放在回调函数中，从而提高了程序的执行效率。
当某个I/O执行完毕时，将以事件的形式通知执行I/O操作的线程，线程执行这个事件的回调函数。为了处理异步I/O，线程必须有事件循环，不断的检查有没有未处理的事件，依次予以处理。
阻塞模式下，一个线程只能处理一项任务，要想提高吞吐量必须通过多线程。而非阻塞模式下，一个线程永远在执行计算操作，这个线程的CPU核心利用率永远是100%。

1.2 单线程

在 Java、PHP 或者 .net等服务器端语言中，会为每一个客户端连接创建一个新的线程。而每个线程需要耗费大约2MB内存。也就是说，理论上，一个8GB内存的服务器可以同时连接的最大用户数为4000个左右。要让Web应用程序支持更多的用户，就需要增加服务器的数量，而 Web 应用程序的硬件成本当然就上升了。
Node.js不为每个客户连接创建一个新的线程，而仅仅使用一个线程。当有用户连接了，就触发一个内部事件，通过非阻塞I/O、事件驱动机制，让 Node.js 程序宏观上也是并行的。使用 Node.js ，一个8GB内存的服务器，可以同时处理超过4万用户的连接。
另外，单线程带来的好处，操作系统完全不再有线程创建、销毁的时间开销。但是单线程也有很多弊端，会在 Node.js 的弊端详细讲解，请继续看。

1.3 事件驱动

在 Node.js 中，客户端请求建立连接，提交数据等行为，会触发相应的事件。在 Node.js 中，在一个时刻，只能执行一个事件回调函数，但是在执行一个事件回调函数的中途，又有其他事件产生，可以转而处理其他事件（比如，又有新用户连接了），然后返回继续执行原事件的回调函数，这种处理机制，称为“事件环”机制。
Node.js 底层是 C++（V8也是C++写的）。底层代码中，近半数都用于事件队列、回调函数队列的构建。用事件驱动来完成服务器的任务调度。

注意这里的事件循环，也可以说是 Node.js 的一个精髓所在，下面引用一段 Node.js 官网的内容

   ┌───────────────────────────┐
┌─>│           timers          │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │
   └───────────────────────────┘

引用Node官网中的一段内容:

注意：每个框将被称为事件循环的“阶段”。每个阶段都有一个要执行的回调FIFO队列。虽然每个阶段都以其自己的方式特殊，但通常情况下，当事件循环进入给定阶段时，它将执行特定于该阶段的任何操作，然后在该阶段的队列中执行回调，直到队列耗尽或最大回调数量为止已执行。当队列耗尽或达到回调限制时，事件循环将移至下一阶段，依此类推。

1.4 跨平台

起初，Node 只能在 Linux 平台上运行。后来随着 Node的发展，微软注意到了它的存在，并投入了一个团队帮助 Node 实现 Windows 平台的兼容，在v0.6.0版本发布时，Node 已经能够直接在 Windows 平台运行了。 Node 是基于libuv实现跨平台的。

2.Node.js的弊端(单线程带来的弊端)

Node.js中有一个特点就是单线程，它带来了很多好处，但是它也有弊端，单线程弱点如下。

1.无法利用多核CPU

2.错误会引起整个应用退出无法继续调用异步I/O

3.大量计算占用CPU导致无法继续调用异步I/O

以上确实是Node的弊端，但是都会有一些对应的解决方案：

弊端1:解决方案

（1）一些管理工具比如pm2，forever 等都可以实现创建多进程解决多核 CUP 的利用率问题;
（2）在v0.8版本之前，实现多进程可以使用child_process;
（3）在v0.8版本之后，可以使用cluster模块，通过主从模式，创建多个工作进程解决多核CPU的利用率问题。

弊端2:解决方案

（1）Nnigx反向代理，负载均衡，开多个进程，绑定多个端口；
（2）一些管理工具比如pm2，forever 等都可以实现进程监控，错误自动重启等;
（3）开多个进程监听同一个端口，使用Node提供的cluster模块；
（4）未出现cluster之前，也可以使用child_process,创建多子线程监听一个端口;
（5）这里说明下，有上面的这些解决方案，但是写node后端代码的时候，异常抛出try catch显得格外有必要。

弊端3:解决方案

（1）可以把大量的密集计算像上面一样拆分成多个子线程计算
（2）但是如果不允许拆分，想计算100万的大数据，在一个单线程中，Node确实显得无能为力，这本身就是V8内存限制的弊端。

说明：child_process与cluster模块我会单独拿一篇文章来讲。值得开心的是上面这些弊端随着Node的版本更新，和新的api模块出现，好像解决了这些弊端。

3.Node.js的应用场景

介绍了Node.js的特点和弊端，再说一下Node.js的应用场景。

Node.js适合用来开发什么样的应用程序呢？

善于I/O，不善于计算。因为Node.js最擅长的就是任务调度，如果你的业务有很多的 CPU 计算，实际上也相当于这个计算阻塞了这个单线程，就不太适合Node开发，但是也不是没有解决方案，只是说不太适合。

当应用程序需要处理大量并发的I/O，而在向客户端发出响应之前，应用程序内部并不需要进行非常复杂的处理的时候，Node.js非常适合。Node.js也非常适合与websocket配合，开发长连接的实时交互应用程序。

具体场景可以表现为如下：

第一大类：用户表单收集系统、后台管理系统、实时交互系统、考试系统、联网软件、高并发量的web应用程序；

第二大类：基于web、canvas等多人联网游戏；

第三大类：基于web的多人实时聊天客户端、聊天室、图文直播；

第四大类：单页面浏览器应用程序；

第五大类：操作数据库、为前端和移动端提供基于json的API；

......

Node事件循环

在理解Node.js的异步的时候有一些不懂的地方，使用Node.js的开发者一定都知道它是单线程的，异步不阻塞且高并发的一门语言，但是Node.js在实现异步的时候，两个异步任务开启了，是就是谁快就谁先完成这么简单，还是说异步任务最后也会有一个先后执行顺序?对于一个单线程的的异步语言它是怎么实现高并发的呢?

好接下来我们就带着这两个问题来真正的理解Node.js中的异步（微任务与事件循环）。

Node.js的异步语法比浏览器更复杂，因为它可以跟内核对话，不得不搞了一个专门的库 libuv 做这件事。这个库负责各种回调函数的执行时间，异步任务最后基于事件循环机制还是要回到主线程，一个个排队执行。

1.本轮循环与次轮循环

异步任务可以分成两种。

追加在本轮循环的异步任务
追加在次轮循环的异步任务

所谓”循环”，指的是事件循环（event loop）。这是 JavaScript 引擎处理异步任务的方式，后文会详细解释。这里只要理解，本轮循环一定早于次轮循环执行即可。

Node 规定，process.nextTick和Promise的回调函数，追加在本轮循环，即同步任务一旦执行完成，就开始执行它们。而setTimeout、setInterval、setImmediate的回调函数，追加在次轮循环。

2.process.nextTick()

1）process.nextTick不要因为有next就被好多小伙伴当作次轮循环。

2）Node 执行完所有同步任务，接下来就会执行process.nextTick的任务队列。

3）开发过程中如果想让异步任务尽可能快地执行，可以使用process.nextTick来完成。

3.微任务（microtack）

根据语言规格，Promise对象的回调函数，会进入异步任务里面的”微任务”（microtask）队列。

微任务队列追加在process.nextTick队列的后面，也属于本轮循环。

注意，只有前一个队列全部清空以后，才会执行下一个队列。两个队列的概念 nextTickQueue 和微队列microTaskQueue，也就是说开启异步任务也分为几种，像promise对象这种，开启之后直接进入微队列中，微队列内的就是哪个任务快就哪个先执行完，但是针对于队列与队列之间不同的任务，还是会有先后顺序，这个先后顺序是由队列决定的。

4.事件循环的阶段（idle, prepare忽略了这个阶段）

事件循环最阶段最详细的讲解（官网：nodejs.org/en/docs/gui…）

1.timers阶段

次阶段包括setTimeout()和setInterval()

2.IO callbacks

大部分的回调事件，普通的callback

3.poll阶段

网络连接，数据获取，读取文件等操作

4.check阶段

setImmediate()在这里调用回调

5.close阶段

一些关闭回调，例如socket.on('close', ...)

5.事件循环注意点

1）Node 开始执行脚本时，会先进行事件循环的初始化，但是这时事件循环还没有开始，会先完成下面的事情：同步任务、发出异步请求、规划定时器生效的时间、执行process.nextTick()等等...

最后，上面这些事情都干完了，事件循环就正式开始了。

2）事件循环同样运行在单线程环境下，高并发也是依靠事件循环，每产生一个事件，就会加入到该阶段对应的队列中，此时事件循环将该队列中的事件取出，准备执行之后的callback。

3）假设事件循环现在进入了某个阶段，即使这期间有其他队列中的事件就绪，也会先将当前队列的全部回调方法执行完毕后，再进入到下一个阶段。

顺序的整体总结就是: 同步任务-> 本轮循环->次轮循环：

node核心模块 - stream

1.stream定义

流（Stream）是一个抽象的数据接口，Node.js中很多对象都实现了流，流是EventEmitter对象的一个实例，总之它是会冒数据（以 Buffer 为单位），或者能够吸收数据的东西，它的本质就是让数据流动起来。可能看一张图会更直观：

注意：stream不是node.js独有的概念，而是一个操作系统最基本的操作方式，只不过node.js有API支持这种操作方式。linux命令的|就是stream。

为什么要使用stream？

因为一次性读取,操作大文件，内存和网络是吃不消的，因此要让数据流动起来，一点点的进行操作。例如视频播放，较大文件读取等。

2.stream流转过程

再次看这张水桶管道流转图

图中可以看出，stream整个流转过程包括source，dest，还有连接二者的管道pipe(stream的核心)，分别介绍三者来带领大家搞懂stream流转过程

stream从哪里来-soucre

stream的常见来源方式有三种：

从控制台输入
http请求中的request
读取文件

这里先说一下从控制台输入这种方式，2和3两种方式stream应用场景章节会有详细的讲解。

看一段process.stdin的代码

process.stdin.on('data', function (chunk) {
    console.log('stream by stdin', chunk)
    console.log('stream by stdin', chunk.toString())
})
//控制台输入koalakoala后输出结果
stream by stdin <Buffer 6b 6f 61 6c 61 6b 6f 61 6c 61 0a>
stream by stdin koalakoala

运行上面代码，然后从控制台输入任何内容都会被data 事件监听到，data 是stream对象用来监听数据传入的一个自定义函数，通过输出结果可看出process.stdin是一个stream对象。

说明： stream对象可以监听"data","end","open","close","error"等事件。node.js中监听自定义事件使用.on方法，例如process.stdin.on(‘data’,…), req.on(‘data’,…),通过这种方式，能很直观的监听到stream数据的传入和结束。

接水桶的管道-pipe

从水桶管道流转图中可以看到，在source和dest之间有一个连接的管道pipe,它的基本语法是source.pipe(dest)，source和dest就是通过pipe连接，让数据从source流向了dest。

stream到哪里去-dest

stream的常见输出方式有三种：

输出控制台
http请求中的response
写入文件

3.stream应用场景

stream的应用场景主要就是处理IO操作，而http请求和文件操作都属于IO操作。这里再提一下stream的本质——由于一次性IO操作过大，硬件开销太多，影响软件运行效率，因此将IO分批分段进行操作，让数据像水管一样流动起来，直到流动完成，也就是操作完成。下面对几个常用的应用场景分别进行介绍

介绍一个压力测试的小工具

一个对网络请求做压力测试的工具ab，ab 全称 Apache bench ，是 Apache 自带的一个工具，因此使用 ab 必须要安装 Apache 。mac os 系统自带 Apache ，windows用户视自己的情况进行安装。运行 ab 之前先启动 Apache ，mac os 启动方式是 sudo apachectl start 。

Apache bench对应参数的详细学习地址，有兴趣的可以看一下 Apache bench对应参数的详细学习地址

介绍这个小工具的目的是对下面几个场景可以进行直观的测试，看出使用stream带来了哪些性能的提升。

get请求中应用stream

这样一个需求：

使用node.js实现一个http请求，读取data.txt文件，创建一个服务，监听8000端口，读取文件后返回给客户端，讲get请求的时候用一个常规文件读取与其做对比，请看下面的例子。

常规使用文件读取返回给客户端response例子，文件命名为getTest1.js

// getTest.js
const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer(function (req, res) {
    const method = req.method; // 获取请求方法
    if (method === 'GET') { // get 请求方法判断
        const fileName = path.resolve(__dirname, 'data.txt');
        fs.readFile(fileName, function (err, data) {
            res.end(data);
        });
    }
});
server.listen(8000);

使用stream返回给客户端response 将上面代码做部分修改，文件命名为getTest2.js

/ getTest2.js
// 主要展示改动的部分
const server = http.createServer(function (req, res) {
    const method = req.method; // 获取请求方法
    if (method === 'GET') { // get 请求
        const fileName = path.resolve(__dirname, 'data.txt');
        let stream = fs.createReadStream(fileName);
        stream.pipe(res); // 将 res 作为 stream 的 dest
    }
});
server.listen(8000);

对于下面get请求中使用stream的例子，会不会有些小伙伴提出质疑，难道response也是一个stream对象，是的没错,对于那张水桶管道流转图,response就是一个dest。

虽然get请求中可以使用stream，但是相比直接file文件读取·res.end(data)有什么好处呢？这时候我们刚才推荐的压力测试小工具就用到了。getTest1和getTest2两段代码，将data.txt内容增加大一些，使用ab工具进行测试，运行命令ab -n 100 -c 100 http://localhost:8000/，其中-n 100表示先后发送100次请求，-c 100表示一次性发送的请求数目为100个。对比结果分析使用stream后，有非常大的性能提升，小伙伴们可以自己实际操作看一下。

post中使用stream

一个通过post请求微信小程序的地址生成二维码的需求。

/*
* 微信生成二维码接口
* params src 微信url / 其他图片请求链接
* params localFilePath: 本地路径
* params data: 微信请求参数
* */
const downloadFile=async (src, localFilePath, data)=> {
    try{
        const ws = fs.createWriteStream(localFilePath);
        return new Promise((resolve, reject) => {
            ws.on('finish', () => {
                resolve(localFilePath);
            });
            if (data) {
                request({
                    method: 'POST',
                    uri: src,
                    json: true,
                    body: data
                }).pipe(ws);
            } else {
                request(src).pipe(ws);
            }
        });
    }catch (e){
        logger.error('wxdownloadFile error: ',e);
        throw e;
    }
}

看这段使用了stream的代码，为本地文件对应的路径创建一个stream对象，然后直接.pipe(ws),将post请求的数据流转到这个本地文件中，这种stream的应用在node后端开发过程中还是比较常用的。

post与get使用stream总结

request和reponse一样，都是stream对象，可以使用stream的特性，二者的区别在于，我们再看一下水桶管道流转图，

request是source类型，是图中的源头，而response是dest类型，是图中的目的地。

在文件操作中使用stream

一个文件拷贝的例子

const fs = require('fs')
const path = require('path')

// 两个文件名
const fileName1 = path.resolve(__dirname, 'data.txt')
const fileName2 = path.resolve(__dirname, 'data-bak.txt')
// 读取文件的 stream 对象
const readStream = fs.createReadStream(fileName1)
// 写入文件的 stream 对象
const writeStream = fs.createWriteStream(fileName2)
// 通过 pipe执行拷贝，数据流转
readStream.pipe(writeStream)
// 数据读取完成监听，即拷贝完成
readStream.on('end', function () {
    console.log('拷贝完成')
})

看了这段代码，发现是不是拷贝好像很简单，创建一个可读数据流readStream，一个可写数据流writeStream,然后直接通过pipe管道把数据流转过去。这种使用stream的拷贝相比存文件的读写实现拷贝，性能要增加很多，所以小伙伴们在遇到文件操作的需求的时候，尽量先评估一下是否需要使用stream实现。

4.stream的种类

Readable Stream 可读数据流
Writeable Stream 可写数据流
Duplex Stream 双向数据流，可以同时读和写
Transform Stream 转换数据流，可读可写，同时可以转换（处理）数据(不常用)

之前的文章都是围绕前两种可读数据流和可写数据流，第四种流不太常用，需要的小伙伴网上搜索一下，接下来对第三种数据流Duplex Stream 说明一下。

Duplex Stream双向的，既可读，又可写。 Duplex streams同时实现了 Readable和Writable 接口。 Duplex streams的例子包括

tcp sockets
zlib streams
crypto streams 我在项目中还未使用过双工流，一些Duplex Stream的内容可以参考这篇文章NodeJS Stream 双工流

5.stream有什么弊端

用 rs.pipe(ws) 的方式来写文件并不是把 rs 的内容 append到 ws 后面，而是直接用 rs 的内容覆盖 ws 原有的内容
已结束/关闭的流不能重复使用，必须重新创建数据流
pipe 方法返回的是目标数据流，如 a.pipe(b) 返回的是 b，因此监听事件的时候请注意你监听的对象是否正确
如果你要监听多个数据流，同时你又使用了 pipe方法来串联数据流的话，你就要写成：

data
        .on('end', function() {
            console.log('data end');
        })
        .pipe(a)
        .on('end', function() {
            console.log('a end');
        })
        .pipe(b)
        .on('end', function() {
            console.log('b end');
        });

node核心模块 -fs模块

文件操作是开发过程中并不可少的一部分。Node.js 中的 fs 模块是文件操作的封装，它提供了文件读取、写入、更名、删除、遍历目录、链接等 POSIX 文件系统操作。与其它模块不同的是，fs 模块中所有的操作都提供了异步和同步的两个版本,具有 sync 后缀的方法为同步方法，不具有 sync 后缀的方法为异步方法

文件常识

1.权限位 mode

因为 fs 模块需要对文件进行操作，会涉及到操作权限的问题，所以需要先清楚文件权限是什么，都有哪些权限。

文件权限表：

在上面表格中，我们可以看出系统中针对三种类型进行权限分配，即文件所有者（自己）、文件所属组（家人）和其他用户（陌生人），文件操作权限又分为三种，读、写和执行，数字表示为八进制数，具备权限的八进制数分别为 4、2、1，不具备权限为 0。

为了更容易理解，我们可以随便在一个目录中打开 Git，使用 Linux 命令 ls -al 来查目录中文件和文件夹的权限位

drwxr-xr-x 1 koala 197121 0 Jun 28 14:41 core
-rw-r--r-- 1 koala 197121 293 Jun 23 17:44 index.md

在上面的目录信息当中，很容易看出用户名、创建时间和文件名等信息，但最重要的是开头第一项（十位的字符）。

第一位代表是文件还是文件夹，d 开头代表文件夹，- 开头的代表文件，而后面九位就代表当前用户、用户所属组和其他用户的权限位，按每三位划分，分别代表读（r）、写（w）和执行（x），- 代表没有当前位对应的权限。

权限参数 mode 主要针对 Linux 和 Unix 操作系统，Window 的权限默认是可读、可写、不可执行，所以权限位数字表示为 0o666，转换十进制表示为 438。

2.标识位 flag

Node.js 中，标识位代表着对文件的操作方式，如可读、可写、即可读又可写等等，在下面用一张表来表示文件操作的标识位和其对应的含义。

上面表格就是这些标识位的具体字符和含义，但是 flag 是不经常使用的，不容易被记住，所以在下面总结了一个加速记忆的方法。

r：读取
w：写入
s：同步
+：增加相反操作
x：排他方式

r+ 和 w+ 的区别，当文件不存在时，r+ 不会创建文件，而会抛出异常，但 w+ 会创建文件；如果文件存在，r+ 不会自动清空文件，但 w+ 会自动把已有文件的内容清空。

3.文件描述符 fs

操作系统会为每个打开的文件分配一个名为文件描述符的数值标识，文件操作使用这些文件描述符来识别与追踪每个特定的文件，Window 系统使用了一个不同但概念类似的机制来追踪资源，为方便用户，NodeJS 抽象了不同操作系统间的差异，为所有打开的文件分配了数值的文件描述符。

在 Node.js 中，每操作一个文件，文件描述符是递增的，文件描述符一般从 3 开始，因为前面有 0、1、2 三个比较特殊的描述符，分别代表 process.stdin（标准输入）、process.stdout（标准输出）和 process.stderr（错误输出）。

文件操作

完整性读写文件操作

文件读取-fs.readFile

fs.readFile(filename,[encoding],[callback(error,data)]

文件读取函数

它接收第一个必选参数filename，表示读取的文件名。
第二个参数 encoding 是可选的，表示文件字符编码。
第三个参数callback是回调函数，用于接收文件的内容。说明：如果不指定 encoding ，则callback就是第二个参数。回调函数提供两个参数 err 和 data ， err 表示有没有错误发生，data 是文件内容。如果指定 encoding ， data是一个解析后的字符串，否则将会以 Buffer 形式表示的二进制数据。 demo:

const fs = require('fs');
const path = require('path');
const filePath = path.join(__dirname,'koalaFile.txt')
const filePath1 = path.join(__dirname,'koalaFile1.txt')
// -- 异步读取文件
fs.readFile(filePath,'utf8',function(err,data){
    console.log(data);// 程序员成长指北
});

// -- 同步读取文件
const fileResult=fs.readFileSync(filePath,'utf8');
console.log(fileResult);// 程序员成长指北

文件写入fs.writeFile

fs.writeFile(filename,data,[options],callback)

文件写入操作

第一个必选参数 filename ，表示读取的文件名
第二个参数要写的数据
第三个参数 option 是一个对象，如下

encoding {String | null} default='utf-8'
mode {Number} default=438(aka 0666 in Octal)
flag {String} default='w'

这个时候第一章节讲的计算机知识就用到了，flag值，默认为w,会清空文件，然后再写。flag值，r代表读取文件，w代表写文件，a代表追加。

demo：

// 写入文件内容（如果文件不存在会创建一个文件）
// 写入时会先清空文件
fs.writeFile(filePath, '写入成功：程序员成长指北', function(err) {
    if (err) {
        throw err;
    }
    // 写入成功后读取测试
    var data=fs.readFileSync(filePath, 'utf-8');
    console.log('new data -->'+data);
});

// 通过文件写入并且利用flag也可以实现文件追加
fs.writeFile(filePath, '程序员成长指北追加的数据', {'flag':'a'},function(err) {
	    if (err) {
	        throw err;
	    }
	    console.log('success');
	    var data=fs.readFileSync(filePath, 'utf-8')
	    // 写入成功后读取测试
	    console.log('追加后的数据 -->'+data);
	});

文件追加-appendFile

fs.appendFile(filename, data, [options], callback)

第一个必选参数 filename ，表示读取的文件名
第二个参数 data，data 可以是任意字符串或者缓存
第三个参数 option 是一个对象，与write的区别就是[options]的flag默认值是”a”，所以它以追加方式写入数据.

说明：该方法以异步的方式将 data 插入到文件里，如果文件不存在会自动创建

demo:

// -- 异步另一种文件追加操作(非覆盖方式)
// 写入文件内容（如果文件不存在会创建一个文件）
fs.appendFile(filePath, '新数据程序员成长指北456', function(err) {
    if (err) {
        throw err;
    }
    // 写入成功后读取测试
    var data=fs.readFileSync(filePath, 'utf-8');
    console.log(data);
});
// -- 同步另一种文件追加操作(非覆盖方式)

fs.appendFileSync(filePath, '同步追加一条新数据程序员成长指北789');

拷贝文件-copyFile

fs.copyFile(filenameA, filenameB，callback)

第一个参数原始文件名
第二个参数要拷贝到的文件名

demo：

// 将filePath文件内容拷贝到filePath1文件内容
fs.copyFileSync(filePath, filePath1);
let data = fs.readFileSync(filePath1, 'utf8');
console.log(data); // 程序员成长指北

删除文件-unlink

fs.unlink(filename, callback)

第一个参数文件路径大家应该都知道了，后面我就不重复了
第二个回调函数 callback

demo:

// -- 异步文件删除
fs.unlink(filePath,function(err){
	if(err) return;
});
// -- 同步删除文件
fs.unlinkSync(filePath,function(err){
    if(err) return;
});

指定位置读写文件操作(高级文件操作)

接下来的高级文件操作会与上面有些不同，流程稍微复杂一些，要先用fs.open来打开文件，然后才可以用fs.read去读，或者用fs.write去写文件，最后，你需要用fs.close去关掉文件。

特殊说明：read 方法与 readFile 不同，一般针对于文件太大，无法一次性读取全部内容到缓存中或文件大小未知的情况，都是多次读取到 Buffer 中。想了解 Buffer 可以看 NodeJS —— Buffer 解读

文件打开-fs.open

fs.open(path,flags,[mode],callback)

第一个参数:文件路径
第二个参数:与开篇说的标识符 flag 相同
第三个参数:[mode] 是文件的权限（可选参数，默认值是0666）
第四个参数:callback 回调函数

demo:

fs.open(filePath,'r','0666',function(err,fd){
   console.log('哈哈哈',fd); //返回的第二个参数为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄
})

demo 说明：返回的第二个参数为一个整数，表示打开文件返回的文件描述符，window中又称文件句柄，在开篇也有对文件描述符说明

文件读取-fs.read

fs.read(fd, buffer, offset, length, position, callback);

六个参数

fd：文件描述符，需要先使用 open 打开，使用fs.open打开成功后返回的文件描述符；
buffer：一个 Buffer 对象，v8引擎分配的一段内存，要将内容读取到的 Buffer；
offset：整数，向 Buffer 缓存区写入的初始位置，以字节为单位；
length：整数，读取文件的长度；
position：整数，读取文件初始位置；文件大小以字节为单位
callback：回调函数，有三个参数 err（错误），bytesRead（实际读取的字节数），buffer（被写入的缓存区对象），读取执行完成后执行。

demo:

const fs = require('fs');
let buf = Buffer.alloc(6);// 创建6字节长度的buf缓存对象

// 打开文件
fs.open('6.txt', 'r', (err, fd) => {
  // 读取文件
  fs.read(fd, buf, 0, 3, 0, (err, bytesRead, buffer) => {
    console.log(bytesRead);
    console.log(buffer);

    // 继续读取
    fs.read(fd, buf, 3, 3, 3, (err, bytesRead, buffer) => {
      console.log(bytesRead);
      console.log(buffer);
      console.log(buffer.toString());
    });
  });
});

// 3
// <Buffer e4 bd a0 00 00 00>

// 3
// <Buffer e4 bd a0 e5 a5 bd>
// 你好

文件写入-fs.write

fs.write(fd, buffer, offset, length, position, callback);

六个参数

fd：文件描述符，使用fs.open 打开成功后返回的；
buffer：一个 Buffer 对象，v8 引擎分配的一段内存，存储将要写入文件数据的 Buffer；
offset：整数，从 Buffer 缓存区读取数据的初始位置，以字节为单位；
length：整数，读取 Buffer 数据的字节数；
position：整数，写入文件初始位置； 6.callback：写入操作执行完成后回调函数，有三个参数 err（错误），bytesWritten（实际写入的字节数），buffer（被读取的缓存区对象），写入完成后执行。

文件关闭-fs.close

fs.close(fd,callback)

第一个参数：fd 文件open时传递的文件描述符
第二个参数 callback 回调函数,回调函数有一个参数 err（错误），关闭文件后执行。

demo:


// 注意文件描述符fd
fs.open(filePath, 'r', (err, fd) => {
  fs.close(fd, err => {
    console.log('关闭成功');// 关闭成功
  });
});

目录(文件夹)操作

1.fs.mkdir 创建目录

fs.mkdir(path, [options], callback)

第一个参数：path 目录路径
第二个参数[options]，recursive 默认值: false。 mode Windows 上不支持。默认值: 0o777。可选的 options 参数可以是指定模式（权限和粘滞位）的整数，也可以是具有 mode 属性和 recursive 属性（指示是否应创建父文件夹）的对象。
第三个参数回调函数,回调函数有一个参数 err（错误），关闭文件后执行。

demo:


fs.mkdir('./mkdir',function(err){
  if(err) return;
  console.log('创建目录成功');
})
注意： 在 Windows 上，在根目录上使用 fs.mkdir() （即使使用递归参数）也会导致错误：

fs.mkdir('/', { recursive: true }, (err) => {
  // => [Error: EPERM: operation not permitted, mkdir 'C:\']
});

2.fs.rmdir删除目录

fs.rmdir(path,callback)

第一个参数：path目录路径
第三个参数回调函数,回调函数有一个参数 err（错误），关闭文件后执行。

demo:

const fs = require('fs');
fs.rmdir('./mkdir',function(err){
  if(err) return;
  console.log('删除目录成功');
})

注意：在文件（而不是目录）上使用 fs.rmdir() 会导致在 Windows 上出现 ENOENT 错误、在 POSIX 上出现 ENOTDIR 错误。

3.fs.readdir读取目录

fs.readdir(path, [options], callback)

第一个参数：path 目录路径
第二个参数[options]可选的 options 参数可以是指定编码的字符串，也可以是具有 encoding 属性的对象，该属性指定用于传给回调的文件名的字符编码。如果 encoding 设置为 'buffer'，则返回的文件名是 Buffer 对象。如果 options.withFileTypes 设置为 true，则 files 数组将包含 fs.Dirent 对象。
第三个参数回调函数,回调函数有两个参数，第一个 err（错误），第二个返回的data 为一个数组，包含该文件夹的所有文件，是目录中的文件名的数组（不包括 '.' 和 '..'）。

demo:

const fs = require('fs');
fs.readdir('./file',function(err,data){
  if(err) return;
  //data为一个数组
  console.log('读取的数据为：'+data[0]);
});

node.js 核心模块- buffer

Buffer对象，类似数组，它的元素为16进制的两位数，即0到255的数值。可以看出stream中流动的数据是Buffer类型，二进制数据，接下来开始我们的Buffer探索之旅。

什么是二进制

二进制是计算机最底层的数据格式，字符串，数字，视频，音频，程序，网络包等，在最底层都是用二进制来进行存储。这些高级格式和二进制之间，都可以通过固定的编码格式进行相互转换。

例如，C语言中int32类型的十进制整数（无符号），就占用32bit即4byte，十进制的3对应的二进制就是00000000 00000000 00000000 00000011。字符串也是同理，可以根据ASCII编码规则或者unicode编码规则（如utf-8）等和二进制进行相互转换。总之，计算机底层存储的数据都是二进制格式，各种高级类型都有对应的编码规则和二进制进行相互转换。

node中为什么会出现Buffer这个模块

在最初的javascript生态中，javascript还运行在浏览器端，对于处理Unicode编码的字符串数据很容易，但是对于处理二进制以及非Unicode编码的数据无能为力，但是对于Server端操作TCP/HTTP以及文件I/O的处理是必须的。我想就是因此在Node.js里面提供了Buffer类处理二进制的数据，可以处理各种类型的数据。

Buffer模块的一个说明。

在Node.js里面一些重要模块net、http、fs中的数据传输以及处理都有Buffer的身影，因为一些基础的核心模块都要依赖Buffer，所以在node启动的时候，就已经加载了Buffer，我们可以在全局下面直接使用Buffer，无需通过require()。且 Buffer 的大小在创建时确定，无法调整。

Buffer创建

在 NodeJS v6.0.0版本之前，Buffer实例是通过 Buffer 构造函数创建的，即使用 new 关键字创建，它根据提供的参数返回不同的 Buffer，但在之后的版本中这种声明方式就被废弃了，替代 new 的创建方式主要有以下几种。

1. Buffer.alloc 和 Buffer.allocUnsafe(创建固定大小的buffer)

用 Buffer.alloc 和 Buffer.allocUnsafe 创建 Buffer 的传参方式相同，参数为创建 Buffer 的长度，数值类型。

// Buffer.alloc 和 Buffer.allocUnsafe 创建 Buffer
// Buffer.alloc 创建 Buffer,创建一个大小为6字节的空buffer，经过了初始化
let buf1 = Buffer.alloc(6);

// Buffer.allocUnsafe 创建 Buffer，创建一个大小为6字节的buffer，未经过初始化
let buf2 = Buffer.allocUnsafe(6);

console.log(buf1); // <Buffer 00 00 00 00 00 00>
console.log(buf2); // <Buffer 00 e7 8f a0 00 00>

通过代码可以看出，用 Buffer.alloc 和 Buffer.allocUnsafe 创建Buffer 是有区别的，Buffer.alloc 创建的 Buffer 是被初始化过的，即 Buffer 的每一项都用 00 填充，而 Buffer.allocUnsafe 创建的 Buffer 并没有经过初始化，在内存中只要有闲置的 Buffer 就直接 “抓过来” 使用。

Buffer.allocUnsafe 创建 Buffer 使得内存的分配非常快，但已分配的内存段可能包含潜在的敏感数据，有明显性能优势的同时又是不安全的，所以使用需格外 “小心”。

2、Buffer.from(根据内容直接创建Buffer)

Buffer.from(str, ) 支持三种传参方式：

第一个参数为字符串，第二个参数为字符编码，如 ASCII、UTF-8、Base64 等等。
传入一个数组，数组的每一项会以十六进制存储为 Buffer 的每一项。
传入一个Buffer，会将 Buffer 的每一项作为新返回 Buffer 的每一项。

说明:Buffer目前支持的编码格式

ascii - 仅支持7位ASCII数据。
utf8 - 多字节编码的Unicode字符
utf16le - 2或4个字节，小端编码的Unicode字符
base64 - Base64字符串编码
binary - 二进制编码。
hex - 将每个字节编码为两个十六进制字符。

传入字符串和字符编码：

// 传入字符串和字符编码
let buf = Buffer.from("hello", "utf8");

console.log(buf); // <Buffer 68 65 6c 6c 6f>

传入数组：

// 数组成员为十进制数
let buf = Buffer.from([1, 2, 3]);

console.log(buf); // <Buffer 01 02 03>
// 数组成员为十六进制数
let buf = Buffer.from([0xe4, 0xbd, 0xa0, 0xe5, 0xa5, 0xbd]);

console.log(buf); // <Buffer e4 bd a0 e5 a5 bd>
console.log(buf.toString("utf8")); // 你好

在 NodeJS 中不支持 GB2312 编码，默认支持 UTF-8，在 GB2312 中，一个汉字占两个字节，而在 UTF-8 中，一个汉字占三个字节，所以上面 “你好” 的 Buffer 为 6 个十六进制数组成。

// 数组成员为字符串类型的数字
let buf = Buffer.from(["1", "2", "3"]);
console.log(buf); // <Buffer 01 02 03>

传入的数组成员可以是任何进制的数值，当成员为字符串的时候，如果值是数字会被自动识别成数值类型，如果值不是数字或成员为是其他非数值类型的数据，该成员会被初始化为 00。

创建的 Buffer 可以通过 toString 方法直接指定编码进行转换，默认编码为 UTF-8。

传入 Buffer：

// 传入一个 Buffer
let buf1 = Buffer.from("hello", "utf8");

let buf2 = Buffer.from(buf1);

console.log(buf1); // <Buffer 68 65 6c 6c 6f>
console.log(buf2); // <Buffer 68 65 6c 6c 6f>
console.log(buf1 === buf2); // false
console.log(buf1[0] === buf2[0]); // true
buf1[1]=12;
console.log(buf1); // <Buffer 68 0c 6c 6c 6f>
console.log(buf2); // <Buffer 68 65 6c 6c 6f>

当传入的参数为一个 Buffer 的时候，会创建一个新的 Buffer 并复制上面的每一个成员。

Buffer 为引用类型，一个 Buffer 复制了另一个 Buffer 的成员，当其中一个 Buffer 复制的成员有更改，另一个 Buffer 对应的成员不会跟着改变，说明传入buffer创建新的Buffer的时候是一个深拷贝的过程。

Buffer的内存分配机制

buffer对应于 V8 堆内存之外的一块原始内存

Buffer是一个典型的javascript与C++结合的模块，与性能有关的用C++来实现，javascript 负责衔接和提供接口。Buffer所占的内存不是V8堆内存，是独立于V8堆内存之外的内存，通过C++层面实现内存申请（可以说真正的内存是C++层面提供的）、javascript 分配内存（可以说JavaScript层面只是使用它）。Buffer在分配内存最终是使用ArrayBuffer对象作为载体。简单点而言，就是Buffer模块使用v8::ArrayBuffer分配一片内存，通过TypedArray中的v8::Uint8Array来去写数据。

内存分配的8K机制

分配小内存
说道Buffer的内存分配就不得不说Buffer的8KB的问题，对应buffer.js源码里面的处理如下：

Buffer.poolSize = 8 * 1024;

function allocate(size)
{
    if(size <= 0 )
        return new FastBuffer();
    if(size < Buffer.poolSize >>> 1 )
        if(size > poolSize - poolOffset)
            createPool();
        var b = allocPool.slice(poolOffset,poolOffset + size);
        poolOffset += size;
        alignPool();
        return b
    } else {
        return createUnsafeBuffer(size);
    }
}

源码直接看来就是以8KB作为界限，如果写入的数据大于8KB一半的话直接则直接去分配内存，如果小于4KB的话则从当前分配池里面判断是否够空间放下当前存储的数据，如果不够则重新去申请8KB的内存空间，把数据存储到新申请的空间里面，如果足够写入则直接写入数据到内存空间里面，下图为其内存分配策略。

看内存分配策略图，如果当前存储了2KB的数据，后面要存储5KB大小数据的时候分配池判断所需内存空间大于4KB，则会去重新申请内存空间来存储5KB数据并且分配池的当前偏移指针也是指向新申请的内存空间，这时候就之前剩余的6KB(8KB-2KB)内存空间就会被搁置。至于为什么会用8KB作为存储单元分配，为什么大于8KB按照大内存分配策略，在下面Buffer内存分配机制优点有说明。

分配大内存还是看上面那张内存分配图，如果需要超过8KB的Buffer对象，将会直接分配一个SlowBuffer对象作为基础单元，这个基础单元将会被这个大Buffer对象独占。

// Big buffer,just alloc one
this.parent = new SlowBuffer(this.length);
this.offset = 0;

这里的SlowBUffer类实在C++中定义的，虽然引用buffer模块可以访问到它，但是不推荐直接操作它，而是用Buffer替代。这里内部parent属性指向的SlowBuffer对象来自Node自身C++中的定义，是C++层面的Buffer对象，所用内存不在V8的堆中。

内存分配的限制
此外，Buffer单次的内存分配也有限制，而这个限制根据不同操作系统而不同，而这个限制可以看到node_buffer.h里面

    static const unsigned int kMaxLength =
    sizeof(int32_t) == sizeof(intptr_t) ? 0x3fffffff : 0x7fffffff;

对于32位的操作系统单次可最大分配的内存为1G，对于64位或者更高的为2G。

buffer内存分配机制优点

Buffer真正的内存实在Node的C++层面提供的，JavaScript层面只是使用它。当进行小而频繁的Buffer操作时，采用的是8KB为一个单元的机制进行预先申请和事后分配，使得Javascript到操作系统之间不必有过多的内存申请方面的系统调用。对于大块的Buffer而言(大于8KB)，则直接使用C++层面提供的内存，则无需细腻的分配操作。

Buffer与stream

stream的流动为什么要使用二进制Buffer

根据最初代码的打印结果，stream中流动的数据就是Buffer类型，也就是二进制。

原因一：

node官方使用二进制作为数据流动肯定是考虑过很多，比如在上一篇想学Node.js，stream先有必要搞清楚文章已经说过，stream主要的设计目的——是为了优化IO操作（文件IO和网络IO），对应后端无论是文件IO还是网络IO，其中包含的数据格式都是未知的，有可能是字符串，音频，视频，网络包等等，即使就是字符串，它的编码格式也是未知的，可能ASC编码，也可能utf-8编码，对于这些未知的情况，还不如直接使用最通用的格式二进制.

原因二：

Buffer对于http请求也会带来性能提升。

举一个例子：

const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer(function (req, res) {
    const fileName = path.resolve(__dirname, 'buffer-test.txt');
    fs.readFile(fileName, function (err, data) {
        res.end(data)   // 测试1 ：直接返回二进制数据
        // res.end(data.toString())  // 测试2 ：返回字符串数据
    });
});
server.listen(8000);

将代码中的buffer-test文件大小增加到50KB左右，然后使用ab工具测试一下性能，你会发现无论是从吞吐量（Requests per second）还是连接时间上，返回二进制格式比返回字符串格式效率提高很多。为何字符串格式效率低？—— 因为网络请求的数据本来就是二进制格式传输，虽然代码中写的是 response 返回字符串，最终还得再转换为二进制进行传输，多了一步操作，效率当然低了。

Buffer在stream数据流转充当的角色

我们可以把整个流(stream)和Buffer的配合过程看作公交站。在一些公交站，公交车在没有装满乘客前是不会发车的，或者在特定的时刻才会发车。当然，乘客也可能在不同的时间，人流量大小也会有所不同，有人多的时候，有人少的时候，乘客或公交车站都无法控制人流量。

不论何时，早到的乘客都必须等待，直到公交车接到指令可以发车。当乘客到站，发现公交车已经装满，或者已经开走，他就必须等待下一班车次。

总之，这里总会有一个等待的地方，这个等待的区域就是Node.js中的Buffer，Node.js不能控制数据什么时候传输过来，传输速度，就好像公交车站无法控制人流量一样。他只能决定什么时候发送数据(公交车发车)。如果时间还不到，那么Node.js就会把数据放入Buffer等待区域中，一个在RAM中的地址，直到把他们发送出去进行处理。

注意点：

Buffer虽好也不要瞎用，Buffer与String两者都可以存储字符串类型的数据，但是，String与Buffer不同，在内存分

配上面，String直接使用v8堆存储，不用经过c++堆外分配内存，并且Google也对String进行优化，在实际的拼接测速对比中，String比Buffer快。但是Buffer的出现是为了处理二进制以及其他非Unicode编码的数据，所以在处理非utf8数据的时候需要使用到Buffer来处理。

深入理解Node.js 中的进程与线程

进程

进程Process是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，进程是线程的容器（来自百科）。进程是资源分配的最小单位。我们启动一个服务、运行一个实例，就是开一个服务进程，例如 Java 里的 JVM 本身就是一个进程，Node.js 里通过 node app.js 开启一个服务进程，多进程就是进程的复制（fork），fork 出来的每个进程都拥有自己的独立空间地址、数据栈，一个进程无法访问另外一个进程里定义的变量、数据结构，只有建立了 IPC 通信，进程之间才可数据共享。

Node.js开启服务进程例子

const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程序员成长指北测试进程';
    console.log('进程id',process.pid)
})

运行上面代码后，以下为 Mac 系统自带的监控工具 “活动监视器” 所展示的效果，可以看到我们刚开启的 Nodejs 进程 7663

线程

线程是操作系统能够进行运算调度的最小单位，首先我们要清楚线程是隶属于进程的，被包含于进程之中。一个线程只能隶属于一个进程，但是一个进程是可以拥有多个线程的。

单线程

单线程就是一个进程只开一个线程

Javascript 就是属于单线程，程序顺序执行(这里暂且不提JS异步)，可以想象一下队列，前面一个执行完之后，后面才可以执行，当你在使用单线程语言编码时切勿有过多耗时的同步操作，否则线程会造成阻塞，导致后续响应无法处理。你如果采用 Javascript 进行编码时候，请尽可能的利用Javascript异步操作的特性。

经典计算耗时造成线程阻塞的例子

const http = require('http');
const longComputation = () => {
  let sum = 0;
  for (let i = 0; i < 1e10; i++) {
    sum += i;
  };
  return sum;
};
const server = http.createServer();
server.on('request', (req, res) => {
  if (req.url === '/compute') {
    console.info('计算开始',new Date());
    const sum = longComputation();
    console.info('计算结束',new Date());
    return res.end(`Sum is ${sum}`);
  } else {
    res.end('Ok')
  }
});

server.listen(3000);
//打印结果
//计算开始 2019-07-28T07:08:49.849Z
//计算结束 2019-07-28T07:09:04.522Z

查看打印结果，当我们调用127.0.0.1:3000/compute 的时候，如果想要调用其他的路由地址比如127.0.0.1/大约需要15秒时间，也可以说一个用户请求完第一个compute接口后需要等待15秒，这对于用户来说是极其不友好的。下文我会通过创建多进程的方式child_process.fork 和cluster 来解决解决这个问题。

单线程的一些说明

Node.js 虽然是单线程模型，但是其基于事件驱动、异步非阻塞模式，可以应用于高并发场景，避免了线程创建、线程之间上下文切换所产生的资源开销。
当你的项目中需要有大量计算，CPU 耗时的操作时候，要注意考虑开启多进程来完成了。
Node.js 开发过程中，错误会引起整个应用退出，应用的健壮性值得考验，尤其是错误的异常抛出，以及进程守护是必须要做的。
单线程无法利用多核CPU，但是后来Node.js 提供的API以及一些第三方工具相应都得到了解决，文章后面都会讲到。

Node.js 中的进程与线程

Node.js 是 Javascript 在服务端的运行环境，构建在 chrome 的 V8 引擎之上，基于事件驱动、非阻塞I/O模型，充分利用操作系统提供的异步 I/O 进行多任务的执行，适合于 I/O 密集型的应用场景，因为异步，程序无需阻塞等待结果返回，而是基于回调通知的机制，原本同步模式等待的时间，则可以用来处理其它任务，

科普：在 Web 服务器方面，著名的 Nginx 也是采用此模式（事件驱动），避免了多线程的线程创建、线程上下文切换的开销，Nginx 采用 C 语言进行编写，主要用来做高性能的 Web 服务器，不适合做业务。

Web业务开发中，如果你有高并发应用场景那么 Node.js 会是你不错的选择。

在单核 CPU 系统之上我们采用单进程 + 单线程的模式来开发。在多核 CPU 系统之上，可以通过 child_process.fork 开启多个进程（Node.js 在 v0.8 版本之后新增了Cluster 来实现多进程架构），即多进程 + 单线程模式。注意：开启多进程不是为了解决高并发，主要是解决了单进程模式下 Node.js CPU 利用率不足的情况，充分利用多核 CPU 的性能。

Node.js 中的进程

process 模块

Node.js 中的进程 Process 是一个全局对象，无需 require 直接使用，给我们提供了当前进程中的相关信息。官方文档提供了详细的说明，感兴趣的可以亲自实践下 Process 文档。

process.env：环境变量，例如通过 process.env.NODE_ENV 获取不同环境项目配置信息
process.nextTick：这个在谈及 Event Loop 时经常为会提到
process.pid：获取当前进程id
process.ppid：当前进程对应的父进程
process.cwd()：获取当前进程工作目录，
process.platform：获取当前进程运行的操作系统平台
process.uptime()：当前进程已运行时间，例如：pm2 守护进程的 uptime 值
进程事件：process.on(‘uncaughtException’, cb) 捕获异常信息、process.on(‘exit’, cb）进程推出监听
三个标准流：process.stdout 标准输出、process.stdin 标准输入、process.stderr 标准错误输出
process.title 指定进程名称，有的时候需要给进程指定一个名称

以上仅列举了部分常用到功能点，除了 Process 之外 Node.js 还提供了 child_process 模块用来对子进程进行操作，在下文 Nodejs进程创建会继续讲述。

Node.js 进程创建

进程创建有多种方式，本篇文章以child_process模块和cluster模块进行讲解。

child_process模块

child_process 是 Node.js 的内置模块

几个常用函数：四种方式

child_process.spawn()：适用于返回大量数据，例如图像处理，二进制数据处理。
child_process.exec()：适用于小量数据，maxBuffer 默认值为 200 * 1024 超出这个默认值将会导致程序崩溃，数据量过大可采用 spawn。
child_process.execFile()：类似 child_process.exec()，区别是不能通过 shell 来执行，不支持像 I/O 重定向和文件查找这样的行为
child_process.fork()：衍生新的进程，进程之间是相互独立的，每个进程都有自己的 V8 实例、内存，系统资源是有限的，不建议衍生太多的子进程出来，通长根据系统CPU 核心数设置。

CPU 核心数这里特别说明下，fork 确实可以开启多个进程，但是并不建议衍生出来太多的进程，cpu核心数的获取方式const cpus = require('os').cpus();,这里 cpus 返回一个对象数组，包含所安装的每个 CPU/内核的信息，二者总和的数组哦。假设主机装有两个cpu，每个cpu有4个核，那么总核数就是8。

fork开启子进程 Demo

fork开启子进程解决文章起初的计算耗时造成线程阻塞。在进行 compute 计算时创建子进程，子进程计算完成通过 send 方法将结果发送给主进程，主进程通过 message 监听到信息后处理并退出。

fork_app.js

const http = require('http');
const fork = require('child_process').fork;

const server = http.createServer((req, res) => {
    if(req.url == '/compute'){
        const compute = fork('./fork_compute.js');
        compute.send('开启一个新的子进程');

        // 当一个子进程使用 process.send() 发送消息时会触发 'message' 事件
        compute.on('message', sum => {
            res.end(`Sum is ${sum}`);
            compute.kill();
        });

        // 子进程监听到一些错误消息退出
        compute.on('close', (code, signal) => {
            console.log(`收到close事件，子进程收到信号 ${signal} 而终止，退出码 ${code}`);
            compute.kill();
        })
    }else{
        res.end(`ok`);
    }
});
server.listen(3000, 127.0.0.1, () => {
    console.log(`server started at http://${127.0.0.1}:${3000}`);
});

fork_compute.js

针对文初需要进行计算的的例子我们创建子进程拆分出来单独进行运算。

const computation = () => {
    let sum = 0;
    console.info('计算开始');
    console.time('计算耗时');

    for (let i = 0; i < 1e10; i++) {
        sum += i
    };

    console.info('计算结束');
    console.timeEnd('计算耗时');
    return sum;
};

process.on('message', msg => {
    console.log(msg, 'process.pid', process.pid); // 子进程id
    const sum = computation();

    // 如果Node.js进程是通过进程间通信产生的，那么，process.send()方法可以用来给父进程发送消息
    process.send(sum);
})

cluster模块

cluster 开启子进程Demo

const http = require('http');
const numCPUs = require('os').cpus().length;
const cluster = require('cluster');
if(cluster.isMaster){
    console.log('Master proces id is',process.pid);
    // fork workers
    for(let i= 0;i<numCPUs;i++){
        cluster.fork();
    }
    cluster.on('exit',function(worker,code,signal){
        console.log('worker process died,id',worker.process.pid)
    })
}else{
    // Worker可以共享同一个TCP连接
    // 这里是一个http服务器
    http.createServer(function(req,res){
        res.writeHead(200);
        res.end('hello word');
    }).listen(8000);

}

cluster模块调用fork方法来创建子进程，该方法与child_process中的fork是同一个方法。 cluster模块采用的是经典的主从模型，Cluster会创建一个master，然后根据你指定的数量复制出多个子进程，可以使用cluster.isMaster属性判断当前进程是master还是worker(工作进程)。由master进程来管理所有的子进程，主进程不负责具体的任务处理，主要工作是负责调度和管理。

cluster模块使用内置的负载均衡来更好地处理线程之间的压力，该负载均衡使用了Round-robin算法（也被称之为循环算法）。当使用Round-robin调度策略时，master accepts()所有传入的连接请求，然后将相应的TCP请求处理发送给选中的工作进程（该方式仍然通过IPC来进行通信）。

开启多进程时候端口疑问讲解：如果多个Node进程监听同一个端口时会出现 Error:listen EADDRIUNS的错误，而cluster模块为什么可以让多个子进程监听同一个端口呢?原因是master进程内部启动了一个TCP服务器，而真正监听端口的只有这个服务器，当来自前端的请求触发服务器的connection事件后，master会将对应的socket具柄发送给子进程。

child_process 模块与cluster 模块总结

无论是 child_process 模块还是 cluster 模块，为了解决 Node.js 实例单线程运行，无法利用多核 CPU 的问题而出现的。核心就是父进程（即 master 进程）负责监听端口，接收到新的请求后将其分发给下面的 worker 进程。

cluster模块的一个弊端

cluster内部隐时的构建TCP服务器的方式来说对使用者确实简单和透明了很多，但是这种方式无法像使用child_process那样灵活，因为一直主进程只能管理一组相同的工作进程，而自行通过child_process来创建工作进程，一个主进程可以控制多组进程。原因是child_process操作子进程时，可以隐式的创建多个TCP服务器，对比上面的两幅图应该能理解我说的内容。

Node.js进程通信原理

前面讲解的无论是child_process模块，还是cluster模块，都需要主进程和工作进程之间的通信。通过fork()或者其他API，创建了子进程之后，为了实现父子进程之间的通信，父子进程之间才能通过message和send()传递信息。

IPC这个词我想大家并不陌生，不管那一张开发语言只要提到进程通信，都会提到它。IPC的全称是Inter-Process Communication,即进程间通信。它的目的是为了让不同的进程能够互相访问资源并进行协调工作。实现进程间通信的技术有很多，如命名管道，匿名管道，socket，信号量，共享内存，消息队列等。Node中实现IPC通道是依赖于libuv。windows下由命名管道(name pipe)实现，*nix系统则采用Unix Domain Socket实现。表现在应用层上的进程间通信只有简单的message事件和send()方法，接口十分简洁和消息化。

IPC通信管道是如何创建的

父进程在实际创建子进程之前，会创建IPC通道并监听它，然后才真正的创建出子进程，这个过程中也会通过环境变量（NODE_CHANNEL_FD）告诉子进程这个IPC通道的文件描述符。子进程在启动的过程中，根据文件描述符去连接这个已存在的IPC通道，从而完成父子进程之间的连接。

Node.js句柄传递

讲句柄之前，先想一个问题，send句柄发送的时候，真的是将服务器对象发送给了子进程？

子进程对象send()方法可以发送的句柄类型

net.Socket TCP套接字
net.Server TCP服务器，任意建立在TCP服务上的应用层服务都可以享受它带来的好处
net.Native C++层面的TCP套接字或IPC管道
dgram.Socket UDP套接字
dgram.Native C++层面的UDP套接字

send句柄发送原理分析

结合句柄的发送与还原示意图更容易理解。

send()方法在将消息发送到IPC管道前，实际将消息组装成了两个对象，一个参数是hadler，另一个是message。message参数如下所示：

{
    cmd:'NODE_HANDLE',
    type:'net.Server',
    msg:message
}

发送到IPC管道中的实际上是我们要发送的句柄文件描述符。这个message对象在写入到IPC管道时，也会通过JSON.stringfy()进行序列化。所以最终发送到IPC通道中的信息都是字符串，send()方法能发送消息和句柄并不意味着它能发送任何对象。

连接了IPC通道的子线程可以读取父进程发来的消息，将字符串通过JSON.parse()解析还原为对象后，才触发message事件将消息传递给应用层使用。在这个过程中，消息对象还要被进行过滤处理，message.cmd的值如果以NODE_为前缀，它将响应一个内部事件internalMessage，如果message.cmd值为NODE_HANDLE,它将取出message.type值和得到的文件描述符一起还原出一个对应的对象。

以发送的TCP服务器句柄为例，子进程收到消息后的还原过程代码如下:

function(message,handle,emit){
    var self = this;
    
    var server = new net.Server();
    server.listen(handler,function(){
      emit(server);
    });
}

这段还原代码，子进程根据message.type创建对应的TCP服务器对象，然后监听到文件描述符上。由于底层细节不被应用层感知，所以子进程中，开发者会有一种服务器对象就是从父进程中直接传递过来的错觉。

Node进程之间只有消息传递，不会真正的传递对象，这种错觉是抽象封装的结果。目前Node只支持我前面提到的几种句柄，并非任意类型的句柄都能在进程之间传递，除非它有完整的发送和还原的过程。

Node.js多进程架构模型

编写主进程

master.js 主要处理以下逻辑：

创建一个 server 并监听 3000 端口。
根据系统 cpus 开启多个子进程
通过子进程对象的 send 方法发送消息到子进程进行通信
在主进程中监听了子进程的变化，如果是自杀信号重新启动一个工作进程。
主进程在监听到退出消息的时候，先退出子进程在退出主进程

// master.js
const fork = require('child_process').fork;
const cpus = require('os').cpus();

const server = require('net').createServer();
server.listen(3000);
process.title = 'node-master'

const workers = {};
const createWorker = () => {
    const worker = fork('worker.js')
    worker.on('message', function (message) {
        if (message.act === 'suicide') {
            createWorker();
        }
    })
    worker.on('exit', function(code, signal) {
        console.log('worker process exited, code: %s signal: %s', code, signal);
        delete workers[worker.pid];
    });
    worker.send('server', server);
    workers[worker.pid] = worker;
    console.log('worker process created, pid: %s ppid: %s', worker.pid, process.pid);
}

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

process.once('SIGINT', close.bind(this, 'SIGINT')); // kill(2) Ctrl-C
process.once('SIGQUIT', close.bind(this, 'SIGQUIT')); // kill(3) Ctrl-\
process.once('SIGTERM', close.bind(this, 'SIGTERM')); // kill(15) default
process.once('exit', close.bind(this));

function close (code) {
    console.log('进程退出！', code);

    if (code !== 0) {
        for (let pid in workers) {
            console.log('master process exited, kill worker pid: ', pid);
            workers[pid].kill('SIGINT');
        }
    }

    process.exit(0);
}

工作进程

worker.js 子进程处理逻辑如下：

创建一个 server 对象，注意这里最开始并没有监听 3000 端口
通过 message 事件接收主进程 send 方法发送的消息
监听 uncaughtException 事件，捕获未处理的异常，发送自杀信息由主进程重建进程，子进程在链接关闭之后退出

// worker.js
const http = require('http');
const server = http.createServer((req, res) => {
	res.writeHead(200, {
		'Content-Type': 'text/plan'
	});
	res.end('I am worker, pid: ' + process.pid + ', ppid: ' + process.ppid);
	throw new Error('worker process exception!'); // 测试异常进程退出、重启
});

let worker;
process.title = 'node-worker'
process.on('message', function (message, sendHandle) {
	if (message === 'server') {
		worker = sendHandle;
		worker.on('connection', function(socket) {
			server.emit('connection', socket);
		});
	}
});

process.on('uncaughtException', function (err) {
	console.log(err);
	process.send({act: 'suicide'});
	worker.close(function () {
		process.exit(1);
	})
})

Node.js 进程守护

什么是进程守护？

每次启动 Node.js 程序都需要在命令窗口输入命令 node app.js 才能启动，但如果把命令窗口关闭则Node.js 程序服务就会立刻断掉。除此之外，当我们这个 Node.js 服务意外崩溃了就不能自动重启进程了。这些现象都不是我们想要看到的，所以需要通过某些方式来守护这个开启的进程，执行 node app.js 开启一个服务进程之后，我还可以在这个终端上做些别的事情，且不会相互影响。，当出现问题可以自动重启。

如何实现进程守护

这里我只说一些第三方的进程守护框架，pm2 和 forever ，它们都可以实现进程守护，底层也都是通过上面讲的 child_process 模块和 cluster 模块实现的，这里就不再提它们的原理。

pm2 指定生产环境启动一个名为 test 的 node 服务

pm2 start app.js --env production --name test

pm2常用api

pm2 stop Name/processID 停止某个服务，通过服务名称或者服务进程ID
pm2 delete Name/processID 删除某个服务，通过服务名称或者服务进程ID
pm2 logs [Name] 查看日志，如果添加服务名称，则指定查看某个服务的日志，不加则查看所有日志
pm2 start app.js -i 4 集群，-i <number of workers>参数用来告诉PM2以cluster_mode的形式运行你的app（对应的叫fork_mode），后面的数字表示要启动的工作线程的数量。如果给定的数字为0，PM2则会根据你CPU核心的数量来生成对应的工作线程。注意一般在生产环境使用cluster_mode模式，测试或者本地环境一般使用fork模式，方便测试到错误。
pm2 reload Name pm2 restart Name 应用程序代码有更新，可以用重载来加载新代码，也可以用重启来完成,reload可以做到0秒宕机加载新的代码，restart则是重新启动，生产环境中多用reload来完成代码更新！
pm2 show Name 查看服务详情
pm2 list查看pm2中所有项目
pm2 monit用monit可以打开实时监视器去查看资源占用情况

Node.js 线程

Node.js关于单线程的误区

const http = require('http');

const server = http.createServer();
server.listen(3000,()=>{
    process.title='程序员成长指北测试进程';
    console.log('进程id',process.pid)
})

仍然看本文第一段代码，创建了http服务，开启了一个进程，都说了Node.js是单线程，所以 Node 启动后线程数应该为 1，但是为什么会开启7个线程呢？难道Javascript不是单线程不知道小伙伴们有没有这个疑问？

解释一下这个原因：

Node 中最核心的是 v8 引擎，在 Node 启动后，会创建 v8 的实例，这个实例是多线程的。

主线程：编译、执行代码。
编译/优化线程：在主线程执行的时候，可以优化代码。
分析器线程：记录分析代码运行时间，为 Crankshaft 优化代码执行提供依据。
垃圾回收的几个线程。

所以大家常说的 Node 是单线程的指的是 JavaScript 的执行是单线程的(开发者编写的代码运行在单线程环境中)，但 Javascript 的宿主环境，无论是 Node 还是浏览器都是多线程的因为libuv中有线程池的概念存在的，libuv会通过类似线程池的实现来模拟不同操作系统的异步调用，这对开发者来说是不可见的。

某些异步 IO 会占用额外的线程 还是上面那个例子，我们在定时器执行的同时，去读一个文件：

const fs = require('fs')
setInterval(() => {
    console.log(new Date().getTime())
}, 3000)

fs.readFile('./index.html', () => {})

线程数量变成了 11 个，这是因为在 Node 中有一些 IO 操作（DNS，FS）和一些 CPU 密集计算（Zlib，Crypto）会启用 Node 的线程池，而线程池默认大小为 4，因为线程数变成了 11。我们可以手动更改线程池默认大小：

process.env.UV_THREADPOOL_SIZE = 64

一行代码轻松把线程变成 71。

Libuv

Libuv 是一个跨平台的异步IO库，它结合了UNIX下的libev和Windows下的IOCP的特性，最早由Node的作者开发，专门为Node提供多平台下的异步IO支持。Libuv本身是由C++语言实现的，Node中的非苏塞IO以及事件循环的底层机制都是由libuv实现的。

libuv架构图

在Window环境下，libuv直接使用Windows的IOCP来实现异步IO。在非Windows环境下，libuv使用多线程来模拟异步IO。

注意下面我要说的话，Node的异步调用是由libuv来支持的，以上面的读取文件的例子，读文件实质的系统调用是由libuv来完成的，Node只是负责调用libuv的接口，等数据返回后再执行对应的回调方法。

Node.js 线程创建

直到 Node 10.5.0 的发布，官方才给出了一个实验性质的模块 worker_threads 给 Node 提供真正的多线程能力。

先看下简单的 demo：

const {
  isMainThread,
  parentPort,
  workerData,
  threadId,
  MessageChannel,
  MessagePort,
  Worker
} = require('worker_threads');

function mainThread() {
  for (let i = 0; i < 5; i++) {
    const worker = new Worker(__filename, { workerData: i });
    worker.on('exit', code => { console.log(`main: worker stopped with exit code ${code}`); });
    worker.on('message', msg => {
      console.log(`main: receive ${msg}`);
      worker.postMessage(msg + 1);
    });
  }
}

function workerThread() {
  console.log(`worker: workerDate ${workerData}`);
  parentPort.on('message', msg => {
    console.log(`worker: receive ${msg}`);
  }),
  parentPort.postMessage(workerData);
}

if (isMainThread) {
  mainThread();
} else {
  workerThread();
}

上述代码在主线程中开启五个子线程，并且主线程向子线程发送简单的消息。

由于 worker_thread 目前仍然处于实验阶段，所以启动时需要增加 --experimental-worker flag，运行后观察活动监视器，开启了5个子线程

worker_thread 模块

worker_thread 核心代码（地址） worker_thread 模块中有 4 个对象和 2 个类，可以自己去看上面的源码。

isMainThread: 是否是主线程，源码中是通过 threadId === 0 进行判断的。
MessagePort: 用于线程之间的通信，继承自 EventEmitter。
MessageChannel: 用于创建异步、双向通信的通道实例。
threadId: 线程 ID。
Worker: 用于在主线程中创建子线程。第一个参数为 filename，表示子线程执行的入口。
parentPort: 在 worker 线程里是表示父进程的 MessagePort 类型的对象，在主线程里为 null
workerData: 用于在主进程中向子进程传递数据（data 副本）

总结

多进程 vs 多线程

属性	多进程	多线程	比较
数据	数据共享复杂，需要用IPC；数据是分开的，同步简单	因为共享进程数据，数据共享简单，同步复杂	各有千秋
CPU、内存	占用内存多，切换复杂，CPU利用率低	占用内存少，切换简单，CPU利用率高	多线程更好
销毁、切换	创建销毁、切换复杂，速度慢	创建销毁、切换简单，速度很快	多线程更好
coding	编码简单、调试方便	编码、调试复杂	多进程更好
可靠性	进程独立运行，不会相互影响	线程同呼吸共命运	多进程更好
分布式	可用于多机多核分布式，易于扩展	只能用于多核分布式	多进程更好

Node.js 知识点汇总

Node.js究竟是什么？

1.特点

1.1 非阻塞异步io

1.2 单线程

1.3 事件驱动

1.4 跨平台

2.Node.js的弊端(单线程带来的弊端)

1.无法利用多核CPU

2.错误会引起整个应用退出无法继续调用异步I/O

3.大量计算占用CPU导致无法继续调用异步I/O

弊端1:解决方案

弊端2:解决方案

弊端3:解决方案

3.Node.js的应用场景

Node事件循环

1.本轮循环与次轮循环

2.process.nextTick()

3.微任务（microtack）

4.事件循环的阶段（idle, prepare忽略了这个阶段）

5.事件循环注意点

node核心模块 - stream

1.stream定义

2.stream流转过程

stream从哪里来-soucre

接水桶的管道-pipe

stream到哪里去-dest

3.stream应用场景

介绍一个压力测试的小工具

get请求中应用stream

post中使用stream

post与get使用stream总结

在文件操作中使用stream

4.stream的种类

5.stream有什么弊端

node核心模块 -fs模块

文件常识

1.权限位 mode

2.标识位 flag

3.文件描述符 fs

文件操作

文件读取-fs.readFile

文件写入fs.writeFile

文件追加-appendFile

拷贝文件-copyFile

删除文件-unlink

指定位置读写文件操作(高级文件操作)

文件打开-fs.open

文件读取-fs.read

文件写入-fs.write

文件关闭-fs.close

目录(文件夹)操作

1.fs.mkdir 创建目录

2.fs.rmdir删除目录

3.fs.readdir读取目录

node.js 核心模块- buffer

什么是二进制

node中为什么会出现Buffer这个模块

Buffer创建

1. Buffer.alloc 和 Buffer.allocUnsafe(创建固定大小的buffer)

2、Buffer.from(根据内容直接创建Buffer)

Buffer的内存分配机制

内存分配的8K机制

buffer内存分配机制优点

Buffer与stream

stream的流动为什么要使用二进制Buffer

Buffer在stream数据流转充当的角色

深入理解Node.js 中的进程与线程

进程

线程

单线程

经典计算耗时造成线程阻塞的例子

单线程的一些说明

Node.js 中的进程与线程

Node.js 中的进程

process 模块

Node.js 进程创建

fork开启子进程 Demo

cluster模块

child_process 模块与cluster 模块总结