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

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

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

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

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

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

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

TCP内容

一个程序员境界的提升，并不在于你写的一首好代码，更在于你能说出代码背后的故事。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.

What's TCP 3次握手

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

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

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

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

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

TCP4次挥手

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状态.

进程？线程？

亲，请问php是一门什么语言? (提示，关于进程)

官方回答: php是一门基于多线程的语言

亲，请问nodeJS是一门什么语言？（提示，关于线程）

官方回答: Node.js是单线程!异步!非阻塞!(不过早已可以实现多进程交互了)

那php和nodeJS区别在哪呢？具体可以见图:

PHP

NodeJS

ok~ 简单吧。

亲，那进程和线程区别是什么嘞？

go die /(ㄒoㄒ)/~~

这算是计算机的基本知识吧。 首先我们需要记住的是，进程包括线程。这非常重要。

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

线程的优势

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

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

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

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

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

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

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

并发,并行原理

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

nodeJS的进程实现

一开始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/n");     }).listen(0); }

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/n");     }).listen(3000);

cluster对应API

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，这便是我们程序员要做的事了。

进程通信

[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发送信息

//开启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负载均衡

现在，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); }

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)。 这个参数不太重要，有兴趣的同学，可以下去学习一下。

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