缓存

缓存是前后端数据交互很重要的一部分，利用缓存可以节约网络带宽，节省花销，具体的实现步骤如下：

const http = require("http");
const url = require("url");
const fs = require("fs");
let server = http.createServer((req,res)=>{
    let {pathname} = url.parse(req.url);
    //读取文件的信息
    fs.stat(`www${pathname}`,(err,stat)=>{
        if(err){
            res.writeHeader(404);
            res.write("Not Found");
            res.end();
        }else{
            //判断客户端的请求头里面是否有if-modified-since
            if(req.headers["if-modified-since"]){
                //获取客户端和服务端文件的修改时间
                let cDate = new Date(req.headers["if-modified-since"]);
                let sDate = new Date(stat.mtimeMs);
                let time_client = Math.floor(cDate.getTime()/1000);
                let time_server = Math.floor(sDate.getTime()/1000);
                if(time_client < time_server){
                    sendToClient();
                }else{
                    res.writeHeader(304);
                    res.write("Not Modified");
                    res.end();
                }
            }else{
                sendToClient();
            }
            function sendToClient(){
                let rs = fs.createReadStream(`www${pathname}`);
                let mDate = new Date(stat.mtimeMs);
                res.setHeader("last-modified",mDate.toUTCString());
                rs.pipe(res);
                rs.on("error",(err)=>{
                    res.writeHeader(404);
                    res.write("Not Found");
                    res.end();
                })
            }
        }
    })
})
server.listen(8080);

进程

nodejs默认是单进程、单线程运行的，但是可以通过官方提供的cluster(集群)模块可以实现多进程机制，可以最大化利用cpu的资源，具体的实现如下：

// cluster的中文意思是集群，目的的最大程度的发挥服务器的cpu性能，多个进程运行相同的代码
const cluster = require("cluster");
let os = require("os");
const http = require("http");
const fs = require("fs");
const url = require("url");
const process = require("process");
//只有主进程才可以去派生其他的进程
//主进程：守护进程 --- 用于派生子进程
//子进程： 工作进程  --- 用于执行代码
if(cluster.isMaster){
    let numCpus = os.cpus().length;
    for(let i =0;i<numCpus;i++){
        cluster.fork();
    }
}else{
    let server = http.createServer((req,res)=>{
        console.log(process.pid);
        let {pathname} = url.parse(req.url);
        let rs = fs.createReadStream(`www${pathname}`);
        rs.pipe(res);
        rs.on("error",(err)=>{
            res.writeHeader(404);
            res.write("Not Found");
            res.end();
        })
    })
    server.listen(8080);
}

虽然平常通过设置为CPU进程数的工作进程，但是可以超过这个数，并且并不是主进程先创建

if (cluster.isMaster) {
  // 循环 fork 任务 CPU i5-7300HQ 四核四进程
  for (let i = 0; i < 6; i++) {
    cluster.fork()
  }
  console.log(chalk.green(`主进程运行在${process.pid}`))
} else {
  app.listen(1314) // export app 一个 Koa 服务器的实例
  console.log(chalk.green(`子进程运行在${process.pid}`))
}
#子进程运行在17768
#子进程运行在5784
#子进程运行在11232
#子进程运行在7904
#主进程运行在12960
#子进程运行在4300
#子进程运行在16056

在主进程中 cluster 表示主进程(用于监听、发送事件), process 是本身的进程，worker 表示子进程，通过 cluster.workers 获取。
在子进程中 process 表示子进程(用于监听、发送事件),也可以通过 cluster.worker 表示当前子进程。
cluster.worker.process 等价于 process(在子进程中)

主进程子进程相互通信

cluster 用于监听 process(child) 子进程触发的各种事件。

worker 在主进程中获取，用于和自身通信。当子进程触发事件时，会返回当前的 worker 以及相关的信息到主进程相应的事件中。

process(parent) 主进程本身的进程实例，在通信过程中基本没有用到。

process(child) 子进程本身的实例，只能在子进程获取用于监听自身的事件。

可见主进程与子进程通过这样一个三角关系互相通信，其中 cluster 和 worker 是在主进程中获取的，process(child) 是子进程。 cluster 通过操作 worker 通知子进程，子进程本身和 cluster 进行通信。为什么要这样设计呢？因为子进程会有多个，只有通过 worker 才能选择和哪个进程通信。