前端进阶-让你升级的网络知识

摘要：一般由客户端发送，用来表示报文段中第一个数据字节在数据流中的序号，主要用来解决网络包乱序的问题。为有效，为无效表示，当数据包得到后，立马给应用程序使用到最顶端用来确保连接的安全。亲，那进程和线程区别是什么嘞这算是计算机的基本知识吧。

在正文之前，我想问大家一个问题:
问:亲，你有基础吗？
答: 有啊，你说前端吗？ 不就是HTML,JS,CSS 吗? so easy~
问: oh-my-zsh... 好吧，那问题来了，挖掘机技术哪家强... 开玩笑。
现在才是问题的正内容。

你知道TCP的基本内容吗？(母鸡啊~)

好吧，那你知道TCP的3次握手，4次挥手吗？(知道一点点)

恩，好，那什么是进程呢？什么是线程呢？(母鸡啊。。)

那并发和并行又是什么呢？(母鸡啊)

OMG, 那nodeJS多进程实现你会吗？（不会呀~~~ md ...这都是些shenmegui）

其实，说多了都是泪，这些都是程序员的基本素质呀。。。 面tencent的时候，被一个总监，骂的阿弥陀佛么么哒. 今天在这里和大家分享一下，我的血泪史。

工欲善其事,必先利其器

一个程序员境界的提升，并不在于你写的一首好代码，更在于你能说出代码背后的故事。ok~ 鸡汤灌完了。我们开始说方法了。
首先这幅图大家必须记得非常清楚才行。

对了还有,
OSI七层模型大家应该烂熟于心的。

其中TCP处理transport层，主要是用来建立可靠的连接。 而建立连接的基础，是他丰富的报文内容(md~超级多).我们先来解释一下。 首先，我们TCP3次握手用的报文就是绿色的"TCP Flags"内容。 通过发送ACK，SYN包实现。具体涉及的Tag详见:

Source Port / Destination Port:这个就是客户端口(源端口)和服务器端口（目的端口）. 端口就是用来区别主机中的不同进程，通过结合源IP和目的IP结合，得出唯一的TCP连接。

Sequence Number(seqNumber): 一般由 客户端发送，用来表示报文段中第一个数据字节在数据流中的序号，主要用来解决网络包乱序的问题。

Acknowledgment Number(ACK): 即就是用来存放客户端发来的seqNumber的下一个信号(seqNumber+1). 只有当 TCP flags中的ACK为1时才有效. 主要是用来解决不丢包的问题。

TCP flags: TCP中有6个首部，用来控制TCP连接的状态.取值为0,1.这6个有:URG，ACK，PSH，RST，SYN，FIN.

URG 当为1时，用来保证TCP连接不被中断, 并且将该次TCP内容数据的紧急程度提升(就是告诉电脑，你丫赶快把这个给resolve了)

ACK 通常是服务器端返回的。 用来表示应答是否有效。 1为有效，0为无效

PSH 表示，当数据包得到后，立马给应用程序使用(PUSH到最顶端)

RST 用来确保TCP连接的安全。 该flag用来表示 一个连接复位的请求。 如果发生错误连接，则reset一次，重新连。当然也可以用来拒绝非法数据包。

SYN 同步的意思,通常是由客户端发送，用来建立连接的。第一次握手时: SYN:1 , ACK:0. 第二次握手时: SYN:1 ACK:1

FIN 用来表示是否结束该次TCP连接。 通常当你的数据发送完后，会自动带上FIN 然后断开连接

恩，基本的TCP内容，大家应该掌握了吧。OK, go on.

还是一样， 先上张图，让大家先看一下。 上面大家已经基本了解了TCP里面相应的字段，现在看看图里面的是不是觉得有些亲切嘞？

其实，大家看上面的图，差不多都已经能够摸清楚，每次发送请求的内容。其实，TCP3次握手是为了建立 稳定可靠的连接。所以也就不存在神马 2次连接等的怪癖。
(图中flag说明:SYN包表示标志位syn=1,ACK包表示标志位ack=1,SYN+ACK包表示标志位syn=1,ack=1)
现在，我们来正式进入3次握手环节。

第一次握手. 客户端向服务器发送一个SYN包，并且添加上seqNumber(假设为x),然后进入SYN_SEND状态，并且等待服务器的确认。

第二次握手: 服务器接受SYN包，并且进行确认，如果该请求有效，则将TCP flags中的ACK 标志位置1， 然后将AckNumber置为(seqNumber+1)，并且再添加上自己的seqNumber(y), 完成后，返回给客户端.服务器进入SYN_RECV状态.(这里服务端是发送SYN+ACK包)

第三次握手 客户端接受ACK+SYN报文后，获取到服务器发送seqNumber(y), 并且 将新头部的AckNumber变为(y+1).然后发送给服务器，完成TCP3次连接。此时服务器和客户端都进入ESTABLISHED状态.

回答一下这个比较尴尬的问题，为什么只有3次握手，而不是4次，或者2次？
很简单呀，因为3次就够了,干嘛用4次。23333. 举个例子吧，假如是2次的话， 可能会出现这样一个情况。

当客户端发送一次请求A后，但是A在网络延迟了很久， 接着客户端又发送了一次B，但是此时A已经无效了。 接着服务器相应了B，并返回TCP连接头，建立连接(这里就2次哈)。 然后，A 历经千山万水终于到服务器了， 服务器一看有请求来了，则接受，由于一开始A带着的TCP格式都是正确的，那么服务器，理所应当的也返回成功连接的flag，但是，此时客户端已经判断该次请求无效，废弃了。 然后服务器，就这么一直挂着(浪费资源)，造成的一个问题是，md, 这个锅是谁的？ 所以，为了保险起见，再补充一次连接就可以了。所以3次是最合适的。在Chinese中，以3为起称为多，如果你用4，5，6，7，8...次的话，这不更浪费吗？

TCP4次挥手，是比较简单的。大家对照上面那个图，我们一步一步进行一下讲解。

第一次挥手: A机感觉此时如果keep-alive比较浪费资源，则他提出了分手的请求。设置SeqNumber和AckNumber之后，向B机发送FIN包, 表示我这已经没有数据给你了。然后A机进入FIN_WAIT_1状态

第二次挥手:B机收到了A机的FIN包，已经知道了A机没有数据再发送了。此时B机会给A机发送一个ACK包，并且将AckNumber 变为 A机传输来的SeqNumber+1. 当A机接受到之后，则变为FIN_WAIT_2状态。表示已经得到B机的许可，可以进行关闭操作。不过此时，B机还是可以向A机发送请求的。

第三次挥手 B机向A机发送FIN包，请求关闭，相当于告诉A机，我这里也没有你要的数据了。然后B机进入CLOSE_WAIT状态.（这里还需要带上SeqNumber，大家看图说话就可以了）

第四次挥手 A机接收到B机的FIN包之后，然后同样，发送一个ACK包给B机。 B机接受到之后，就断开了。 而A机 会等待2MSL之后，如果没有回复，确保服务器端确实是关闭了。然后A机也可以关闭连接。A,B都进入了CLOSE状态.

明白了吗？
大哥~ 等等，什么是2MSL呀~
哦，对哦。 这个还么说...
2MSL=2*MSL. 而MSL其实就是Maximum Segment Lifetime，中文意思就是报文最大生存时间。RFC 793中规定MSL为2分钟，实际应用中常用的是30秒，1分钟和2分钟等。 同样上面的TIME_WAT状态其实也就是2MSL状态。 如果超过改时间，则会将该报文废弃，然后直接进入CLOSED状态.

亲，请问php是一门什么语言? (提示，关于进程)
官方回答: php是一门基于多线程的语言
亲，请问nodeJS是一门什么语言？（提示，关于线程）
官方回答: Node.js是单线程!异步!非阻塞!(不过早已可以实现多进程交互了)
那php和nodeJS区别在哪呢？具体可以见图:
PHP

NodeJS

ok~ 简单吧。
亲，那进程和线程区别是什么嘞？
go die /(ㄒoㄒ)/~~
这算是计算机的基本知识吧。 首先我们需要记住的是，进程包括线程。这非常重要。

进程就是系统分配资源的基本单位(比如CPU,内存等)
线程就是程序执行的最小单位

进程有自己的空间，如果一个进程崩溃不会引起其它进程的崩溃。
线程，没有自己独立的空间，多个线程共享的是进程的地址空间，当然处理一些基本的如程序计数器,一组寄存器和栈等。
如果一个线程崩溃，它所在的进程就崩溃了。 虽然说，多进程很稳定，但是进程切换时，耗费的资源也是很大的。 所以对于大并发的nodeJS来说，使用多线程的效果要远远比多进程快，稳定。

1.系统在启动一个进程的时候，会首先在资源中独立一块出来，在后台建立一些列表进行维护。 而，线程是比进程低一个level的，所以创建线程所耗费的资源要远远比，创建进程的资源少。

由于进程本身就比较复杂，所以如果进行进程切换的话，造成的性能损耗也是不言而喻的(因为多个进程独立，在切换的时候还需要保证各自的独立性)。 而线程切换就不同了，因为在处在同一进程下面，对于其他的进程都是透明化的(内存共享)，所以在进行进程切换时，所耗费的资源远远比进程切换的小。

在Linux和window下，CPU的分配是根据线程数来的，如果

总线程数<= CPU数量：并行运行
总线程数> CPU数量：并发运行

并行指的是，当你的CPU核数比线程数多的话，则会将每个线程都分在一个CPU核里进行处理。

并发指的是，当你的CPU核数比线程数少的话，则会利用“时间片轮转进程调度算法”，对每个线程进行同等的运行。

4.细化进程的处理，通常一个进程可以拆分为多个线程进行处理，就和模块化处理是类似的，使用模块化书写的效果要远远比使用单main入口方式书写 清晰，稳定。

亲， 并发和并行有什么共同点吗？
恩~ 有的， 他们都有个‘并’子，字面上看起来都是同时执行的意思。
没错，当然只是字面上而已。
实际上，并发和并行是完全不同的概念。 这里主要和CPU核数有关。这里为了理解，拿线程来作为参考吧。
当你的

总线程数<= CPU数量：并行运行
总线程数> CPU数量：并发运行

很明显，并行其实是真正意义上的同时执行。 当线程数< CPU核数时，每个线程会独立分配到一个CPU里进行处理。
大家看过火影忍者吗？
没错，就是鸣人 出关 口遁九尾之后。 他使用影分身，跑去各地支援同伴，对抗斑。 这里类比来说，就可以理解为， 每个CPU 都是鸣人的一个影分身，他们执行这各自不同的工作，但是，在同一时间上，他们都在运行。 这就是并行。
那并发嘞？
其实，并发有点难以理解，他做的工作其实，就是利用一系列算法实现，并行做的事。一个比较容易理解的就是“时间片轮转进程调度算法”。
即: 在系统控制下，每个线程轮流使用CPU，而且，每个线程使用时间必须很短(比如10ms), 所以这样切换下来。我们(愚蠢的人类，哈哈哈), 天真的以为任务，真的是在"并行"执行.

一开始nodeJS最令人诟病的就是他的单线程特性。既是绝招也是死穴，不过nodeJS发展很快，在v0.8版本就已经添加了cluster作为内置模块，实现多核的利用。
关于nodeJS的进程模块，最主要的当然还是cluster. 通过调用child_process.fork()函数来开启进程。 先看一个具体的demo(from 官网)

var cluster = require("cluster");
var http = require("http");
var numCPUs = require("os").cpus().length;

if (cluster.isMaster) {
    console.log("master start...");

    // Fork workers.
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    //用来监听子worker创建监听服务
    cluster.on("listening",function(worker,address){
        console.log("listening: worker " + worker.process.pid +", Address: "+address.address+":"+address.port);
    });

    cluster.on("exit", function(worker, code, signal) {
        console.log("worker " + worker.process.pid + " died");
    });
} else {
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end("hello world
");
    }).listen(0);
}

存放为app.js 然后运行node app.js就可以实现一个简单的多进程效果。
结果可能为下:

master start...
listening: worker 1559, Address: null:57803
listening: worker 1556, Address: null:57803
listening: worker 1558, Address: null:57803
listening: worker 1557, Address: null:57803

可以从上面的demo中看出，通过cluster.isMaster来区分master和worker. 而master和worker之间使用listen(0)进行通信.

server.listen(0):在master和worker通信过程，集群中的worker会打开一个随机端口共用，通过socket通信像上例中的57803

当然你也可以手动打开一个端口共享监听。像这样.

 http.createServer(function(req, res) {
        res.writeHead(200);
        res.end("hello world
");
    }).listen(3000);

cluster对象的属性和函数

cluster.setttings:配置集群参数对象

cluster.isMaster:判断是不是master节点*

cluster.isWorker:判断是不是worker节点*

Event: "fork": 监听创建worker进程事件

Event: "online": 监听worker创建成功事件

Event: "listening": 监听worker开启的http.listen

Event: "disconnect": 监听worker断线事件

Event: "exit": 监听worker退出事件

Event: "setup": 监听setupMaster事件

cluster.setupMaster([settings]): 设置集群参数

cluster.fork([env]): 创建worker进程

cluster.disconnect([callback]): 关闭worket进程*

cluster.worker: 获得当前的worker对象*

cluster.workers: 获得集群中所有存活的worker对象*

通过cluster.worker获得的worker对象和相应的参数

worker.id: 进程ID号

worker.process: ChildProcess对象*

worker.suicide: 在disconnect()后，判断worker是否自杀*

worker.send(message, [sendHandle]):* master给worker发送消息。注：worker给发master发送消息要用process.send(message)

worker.kill([signal="SIGTERM"]): 杀死指定的worker，别名destory()*

worker.disconnect(): 断开worker连接，让worker自杀

Event: "message": 监听master和worker的message事件

Event: "online": 监听指定的worker创建成功事件

Event: "listening": 监听master向worker状态事件

Event: "disconnect": 监听worker断线事件

Event: "exit": 监听worker退出事件

这些就是cluster的全部内容。不过这仅仅只是内容而已，如果使用cluster，这便是我们程序员要做的事了。

由于nodeJS 只能实现单进程的效果，所以他的进程数只能为一个，但是通过引用cluster模块，可以开启多个子进程实现CPU的利用。
简单进程交互
运行后的结果为:

[master] start master...
[master] fork: worker1
[master] fork: worker2
[master] fork: worker3
[master] fork: worker4
[master] online: worker1
[master] online: worker4
[master] online: worker2
[master] online: worker3
[worker] start worker ...1
[worker] start worker ...4
[worker] start worker ...2
[master] listening: worker4,pid:990, Address:null:3000
[master] listening: worker1,pid:987, Address:null:3000
[master] listening: worker2,pid:988, Address:null:3000
[worker] start worker ...3
[master] listening: worker3,pid:989, Address:null:3000

参照注释代码和上述的结果，我们可以很容易的得到一个触发逻辑。
运行过程是:

首先fork子进程

触发fork事件

创建成功，触发online事件

然后重新执行一遍app.js,通过isWorker判断子进程

创建子进程服务->触发master上的listening

st=>start: 首先fork子进程
op1=>operation: 触发fork事件
op2=>operation: 创建成功，触发online事件
op3=>operation: 然后重新执行一遍app.js,通过isWorker判断子进程
op4=>operation: 创建子进程服务->触发master上的listening
e=>end

st->op1->op2->op3->op4->e

上面只是创建满负载子进程的流程。 但怎样实现进程间的交互呢？ 很简单，master和worker监听message事件，通过传递参数，进行交互。

cluster.worker.send(message[,handleFn]) master向worker发送信息

process.send(message[,handleFn]); worker向master发送信息

这个是多进程之间的通信
communication
我们来分解一下代码块:

//开启master监听worker的通信
cluster.workers[id].on("message", function(msg){
          //...
        });
        
//开启worker监听master的通信
process.on("message", function(msg) {
       //...
    });

运行上面的demo. 这里就不细说，整个流程，只看一下信息通信这一块了。

创建子进程,触发listening事件

使用process.on监听message

接受master发送过来的消息

再向master返回消息

st=>start: 创建子进程,触发listening事件
op1=>operation: 使用process.on监听message
op2=>operation: 接受master发送过来的消息
op3=>operation: 再向master返回消息
op4=>operation: others
e=>others

st->op1->op2->op3->op4

现在，nodeJS负载均衡应该是最容易实现的，其内部已经帮我们封装好了，我们直接调用就over了。
其中，实现负载均衡的模块就是cluster。以前cluster确实很累赘。负载均衡的算法实现的不是很好，导致的下场就是npm2的兴起。不过现在已经实现了负载均衡，官方说法就是用round-robin,来进行请求分配。 round-robin其实就是一个队列的循环，灰常容易理解。先看一下，cluster封装好实现的负载均衡.

var cluster = require("cluster");
var http = require("http");
var numCPUs = require("os").cpus().length;

if (cluster.isMaster) {
    console.log("[master] " + "start master...");

    for (var i = 0; i < numCPUs; i++) {
         cluster.fork();
    }

    cluster.on("listening", function (worker, address) {
        console.log("[master] " + "listening: worker" + worker.id + ",pid:" + worker.process.pid + ", Address:" + address.address + ":" + address.port);
    });

} else if (cluster.isWorker) {
     console.log("[worker] " + "start worker ..." + cluster.worker.id);
    var num = 0;
    http.createServer(function (req, res) {
        num++;
        console.log("worker"+cluster.worker.id+":"+num);
        res.end("worker"+cluster.worker.id+",PID:"+process.pid);
    }).listen(3000);
}

（哥哥，你骗人，这哪里实现了负载均衡，这不就是上面的算法么？)
是呀，，， 我又没说负载均衡不是这个。
负载均衡就是帮你解决请求的分配问题。ok~ 为了证明，我没有骗你，我们来进行测试一下。
使用brew安装siege测试,当然你也可以使用其他测试工具，不过在MAC 上面最好使用siege和webbench或者ab，我这里使用siege

brew install siege

使用的测试语法就是

siege -c 并发数 -t 运行测试时间 URL

测试的时间后面需要带上单位，比如s,m,h,d等。默认单位是m(分钟). 举个例子吧.

siege -c 100 -t 10s http://girls.hustonline.net

对女生节网页进行 100次并发测试，持续时间是10s.
当然siege里还有其他的参数.

-c NUM 设置并发的数量.eg: -c 100; //设置100次并发

-r NUM 设置发送几轮的请求，即，总的请求数为: -cNum*-rNum但是, -r不能和-t一起使用(为什么呢？你猜).eg: -r 20

-t NUM 测试持续时间，指你运行一次测试需要的时间，在timeout后，结束测试.

-f file. 用来测试file里面的url路径.file的尾缀需要为.url. eg: -f girls.url.

-b . 就是询问开不开启基准测试(benchmark)。 这个参数不太重要，有兴趣的同学，可以下去学习一下。

siege常用的就是这几个. 通常我们是搭配 -c + -r 或者-c + -t.
OK，现在我们开始我们的测试 procedure.
首先开启多进程NodeJS. node app.js
使用siege -c 100 -t 10s 127.0.0.1:3000. (Ps: 当然也可以使用http://localhost:3000进行代替)
得到的结果为

Transactions:                 600 hits
Availability:              100.00 %
Elapsed time:                6.08 secs
Data transferred:            0.01 MB
Response time:                0.01 secs
Transaction rate:           98.68 trans/sec
Throughput:                0.00 MB/sec
Concurrency:                0.88
Successful transactions:         600
Failed transactions:               0
Longest transaction:            0.04
Shortest transaction:            0.00

在10s内，发起了600次请求，最大的峰值是98.68 trans/sec。 通过统计分析，得到每个worker的分发量.

worker1:162
worker2:161
worker3:167
worker4:170

可以看出，基本上每个负载上分配的请求的数目都差不多。这就已经达到了负载均衡的效果。
下一篇会对nodeJS已经相关的测试工具做一些介绍哦。
尽请期待。
ending~

大家如果感兴趣，给我一杯咖啡喝喝吧~

转载请注明出处和作者
原文连接:https://segmentfault.com/a/1190000004569460