iOS 对服务器负荷选择问题，解决方案： - 简书
iOS 对服务器负荷选择问题，解决方案：
这个是我面试的一道题：解决方案在下面 如果能够帮到你，请喜欢 关注一下。严重鄙视伸手党。一、解决方案设计题：考虑灾备（比如由于火灾、断电等原因导致服务器不可用）与负载（指突然间有大量客户端访问数据导致服务器任务量加大），公司在a、b两机房分别部署了服务器，请你设计客户端访问服务端的方案，以便达到最优交互体验。一．灾备解决方案：根据请求服务器a的响应来判断服务器的状态，200是正常，非200是错误，错误切换另一个服务器b，并且设置默认下次访问服务器b；下面的解决方案一并解决此方案；二．负载解决方案：在服务器方面来看待是，正常来说完成一次访问，通常在0.1-5s间，正常的情况下取1s一次访问来说，APP每次访该资源到服务器响应后得到数据有一个时间过程；在服务器测试阶段，同时访问服务器的用户数量不同，响应时间不同；举例:1000个用户同时访问，从访问到拿到数据时间为梯度t1s2000个用户同时访问，从访问到拿到数据时间为梯度t2s3000个用户同时访问，从访问到拿到数据时间为梯度t3s…………当然可以分的更细一点。当一个服务器的资源对一个APP接受访问的时候，就相当于已经为一个APP开启一个线程了，对于服务器的情况不同同时开启的线程数不同，当大量客户端访问服务器的时候，服务器开启的线程就会增多，线程一增多每个线程分得的时间片就少，相对于来说用户访问数据的时间就长了。在服务器方面来看待是，APP每次访该资源到服务器响应后得到数据有一个时间过程，此时app可以记录此次访问用得的时间timeA，在APP测试的阶段设定访问时间段为标准值假如设定t1s，当本次APP访问服务器a的时间大于t1s的时候下次再次访问服务器就是访问服务器b，同时记录此次时间段timeNow，如果timeNow& t1，此时说明两台服务器各自访问人数均在1000人以上，此时标准值为第二梯度值t2s；当用户在高梯度值访问一段时间后，此时标准值自动设置成比当前梯度值低一级，这样就能解决当服务器a，b;都在大负荷的时候，此时假如其中一台服务器a用户量降低了；另一太服务器的负荷能力；依次类推每次获得的timeNow跟梯度值对比，再对服务器访问的时间对比；把服务器的访问时间梯度值分的越细，用户体验就越好，因为这些用户对服务器的选择更合理；
? 不离日用常行内，直到先天未画前冷眼看“金牌服务”之一_传奇三_新浪游戏_新浪网
战士在生的一边去制造死亡，法师站在死的一侧去博取生存，道士则在生死之门来来往往……
新手指南区
异界之门资料片
战士在生的一边去制造死亡，法师站在死的一边去博取生存，道士则在生死之门来来往往
冷眼看“金牌服务”之一　
亲亲可人儿
　　冷眼看“金牌服务”之一：登录困难
　　作为一个传奇系列的老玩家，盛大的《传奇》、《传世》、光通的《传奇3》我都玩，每天的必做的事情就是照看其中的N多帐号。
　　今天早上去《传奇3》官网看经验爆率翻倍的时间表的时候，看到一条套红的醒目新闻――“光通全力技术攻关，立志打造金牌服务”的牛大标题。不觉寒一个。脑子里在想，光通又在搞什么东东呀？打开页面一看，抛开那些GT标榜自己的话不说，主要提到了正在进行技术攻关，在近期为玩家解决“登录困难”、“卡机”、“结婚状态异常消失”等三大问题。以此为基础，对玩家做出“金牌服务”云云。
　　看到这里，我就在想，难道光通已经拿出了什么办法？还是又搞搞皮毛功夫，纯粹炒作而已？作为一位一直以来坚持玩《传3》，并为朋友架设过《传3》SF的资深玩家来说，看到光通这次来炒作什么所谓的金牌服务，就要在此翻翻白眼了、横眉冷对一下了。
　　光通如何实现承诺？我有一些怀疑，既然它明确提出了要解决这三大问题，我到要看看它能拿出什么办法来解决这些问题。。。我就以我在架设SF和管理SF的时候所遇到的类似的情况和经验来批一下吧！
　　光通说首先解决登录困难问题，好，我就先批这个问题：
　　玩《传奇3》的玩家大概没有谁没有遇到过这个问题吧？每次不断出现的那个“连接服务器失败”的弹出框就足够把你气死。作为普通玩家，在登陆的时候，就遇到这个问题，的确够烦人的，相信只要有四五次以上连接不成功，至少有50%的玩家要选择不再进入了吧？
　　为什么会造成这个问题？就要从《传奇3》的登录原理来说了。其实只要当玩家点击了《传奇3》的分区列表后，系统就开始发出一个连接请求，向《传奇3》的登录服务器去建立连接。如果这时登录服务器繁忙或者不响应该请求，那么我们自然无法得到回应，所以显示为“连接服务器失败”，连输入帐号的机会都没有了。
　　为什么登录服务器对我们的连接请求不响应呢？以前我也不太清楚，但是自从和朋友一起搞了SF后也知道了一二。首先必须要提到的一个关键因素――外挂(脱机外挂)。我们知道，如果我们使用正常的手动输入的情况进行游戏登录，速度绝对是无法和外挂的每2-3秒连接一次比较的。我们刚架设私服的时候，由于版本问题，不和公服的对应，所有没有外挂问题。当我们升级到和公服一样的时候，各种脱机外挂就可以使用了。平时不出问题还好，一旦游戏服务器出现故障的时候，脱机外挂就会像洪水一样的涌到了登陆服务器上。这时候真可怜了我的那台P4-2.0G的服务器，繁忙的一塌糊涂。后台的帐号验证服务器也是一片繁忙…...哪个惨哦。其实啊，这个就象千军万马排队过独木桥一样。手动登陆既然没有外挂登陆快，自然就被排到了队伍的最后边，假如服务器只能同时处理1000个请求，而手动的请求被排到了1050，服务器当然就不响应你罗！相信在GT使用外挂的人远远要多过我SF里的人，虽然GT的服务器可能比我的P4-2.0要好的多，但是如果有好几千的登录请求，那么也很可能达到了windows2000本身的网络连接数量上限，所以windows2000系统自然会把超过上线的请求拒之门外。这就是我们为什么会被显示“连接服务器失败”的原因了。
　　再来说网络的黑客攻击，这就涉及到了TIP/IP协议本身漏洞的问题，稍微有点网络知识的人都知道“拒绝服务攻击”吧！说白了就是服务器每收到一个请求，就会返回一个封包给“请求方”并等待“请求方”发出封包进行第三次握手的确认。如果收到回应，则可建立连接。如果一直得不到回应，则等待X秒后，才将这个请求给踢出，继续处理下一个请求。
　　但是如果有人向服务器发送大量伪造过IP地址的封包，而该IP地址又并不存在，那么此时服务器就需要对这些封包一一回应，并且一一等待，直到踢出。如果这些封包源源不断的发向服务器，最终服务器会因为积累的等待时间过长导致很多的数据封包无法处理。自然就没有办法处理正常的登陆请求了。
　　上面是按照SF的登录模式分析出来的登录困难的情况，我相信《传奇3》的情况也差不多。那么要解决这个问题，只有三个办法：
　　1：打击外挂。外挂是海量连接请求的根源。不过，不准使用外挂，哈哈！饶命吧？不用外挂，谁来玩呀？我就挂了N多号的。这个不可能。光通不会用这个和自己收入过不去的办法吧？
　　2：购买功能强大的防火墙，修改windows2000注册表来阻止绝大多数的攻击。(PS：谁能够给我投资点钱搞个好点的防火墙啦…..55555…..喔是穷人…..55555)
　　3：提升登陆服务器和后台验证服务器的效率。尽量使后台读取数据进行验证的时间缩短，并扩大进入后台验证服务器的瓶颈(比如原来只能同时验证1000人的服务器升级到能够同时验证2000人)我的SF小本投资只用了台普通的P4服务器，但是光通的用户数量要比我们多的多，所以对数据库服务器处理能力的要求就要高的多，自然配置要相当高的，价格嘛，嘿嘿～～我可是没有那么多MON来搞的。光通如果能舍得为玩家投入扩容的话，相信这个问题也能得到很好的解决，不过，以现在《传奇3》如此多的区组来说的话。这个投资可不是一个小数目哟。。。？
　　相信光通的办法就不出其中了。就看他们是否真正能为玩家舍得这样大的技术投入和支持了。
　　累死了，今天就写到这里，下次来批卡机问题。支持的人多我就写快点，大家快顶矮
开发公司：Wemade（韩国）
代理公司：
官方网站：
收费日期：日
客服电话：021- 客服信箱：
角色恢复：
密码找回：
Copyright & 1996 - 2004 SINA Inc.
All Rights ReservedStack Overflow 2016最新架构如下：&br&&img src=&/2c2a26d163af9f31c11d80192afdd5c5_b.jpg& data-rawwidth=&750& data-rawheight=&524& class=&origin_image zh-lightbox-thumb& width=&750& data-original=&/2c2a26d163af9f31c11d80192afdd5c5_r.jpg&&&ul&&li&4台数据库服务器（微软SQL Server），其中两台更新硬件配置&/li&&li&11台Web服务器（IIS），都已更新硬件配置&/li&&li&2台分布式缓存和消息处理服务器（Redis），都已更新硬件配置&/li&&li&3台应用服务器（实现了tag引擎功能），其中两台为新硬件配置&/li&&li&3台搜索服务器（ElasticSearch），配置同2013年&/li&&li&4台负载均衡服务器（HAProxy），其中新增加的两台用于支持CloudFlare的CDN加速服务&/li&&li&2台网络交换机（每个都是Cisco Nexus 5596 + Fabric Extenders，并升级网卡10Gbps)2台Fortinet 800C（替代2台Cisco 5525-X ASA防火墙）&/li&&li&2台Ciso ASR-1001路由器（替代2台Cisco 3945路由器)&/li&&li&2台Ciso ASR-1001-x路由器&/li&&/ul&详细信息可以看这里&a href=&///?target=http%3A//www./news/view/119d55a& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Stack Overflow 2016最新架构探秘&i class=&icon-external&&&/i&&/a&&br&&br&首先，不知轮子哥在描述中忘(wu)了(shi)&2台分布式缓存和消息处理服务器&、“3台应用服务器（实现了tag引擎功能）”、“3台搜索服务器”是为啥。&br&&br&其次，要说iis服务器确实真牛逼，我这里有一点数据，仅供参考：&br&&img src=&/f6ffb3b5e2d_b.png& data-rawwidth=&902& data-rawheight=&917& class=&origin_image zh-lightbox-thumb& width=&902& data-original=&/f6ffb3b5e2d_r.png&&&br&数据来自微软的aspnet开源项目组：&a href=&///?target=https%3A///aspnet/benchmarks& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&GitHub - aspnet/benchmarks: Benchmarks for ASP.NET 5&i class=&icon-external&&&/i&&/a&&br&&a href=&///?target=http%3A//asp.net& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&asp.net&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a& core的进步很大，已经快赶上iis了啊，然而iis也就是netty的一半多一点吧。&br&由此可以看出，以栈溢出网程序员的技术能力和资金，性能上再上一个档次也不是没有可能，如果他们没选iis的话。（逃
Stack Overflow 2016最新架构如下： 4台数据库服务器（微软SQL Server），其中两台更新硬件配置11台Web服务器（IIS），都已更新硬件配置2台分布式缓存和消息处理服务器（Redis），都已更新硬件配置3台应用服务器（实现了tag引擎功能），其中两台为新硬件配…
&p&游戏服务器常常有心跳包的设计。&/p&&br&&p&我们的心跳包就是为了防止Socket断开连接，或是TCP的连接断开吗？&/p&&br&&p&答案是否定的，TCP连接的通道是个虚拟的，连接的维持靠的是两端TCP软件对连接状态的维护。&/p&&p&TCP 连接自身有维护连接的机制，说白了就是自身有长时间没有数据包情况下的判断连接是否还存在的检测，清除死连接，即使在没有数据来往的时候，TCP也就可以（在启动TCP这个功能的前提下）自动发包检测是否连接正常，这个不需要我们处理。&/p&&br&&b&服务端设计心跳包的目的：&/b&&br&探知对端应用是否存活，服务端客户端都可以发心跳包，一般都是客户端发送心跳包，服务端用于判断客户端是否在线，从而对服务端内存缓存数据进行清理（玩家下线等）；问题在于，通过TCP四次握手断开的设定，我们也是可以通过Socket的read方法来判断TCP连接是否断开，从而做出相应的清理内存动作，那么为什么我们还需要使用客户端发送心跳包来判断呢？&br&&br&&b&第一种判断客户端是否在线策略:&/b&&br&&b&直接监控TCP传输协议的返回值，通过返回值处理应用层的存活判断&/b&&br&&b&比如在C++当中&/b&&br&&b&使用poll的IO复用方法时：&/b&&br&&b&if(fds[i].revents & POLLERR) &/b&&br&&b&if(fds[i].events & POLLDHUP)&/b&&br&&b&通过上述判断可以探知TCP连接的正确性从而在服务器也关闭对应的连接&/b&&br&close() on the file descriptor will release resources that are still being reserved on behalf of the socket. 此时调用close()函数才会释放相关的资源。&br&&br&比如说进行如下处理：&br&&div class=&highlight&&&pre&&code class=&language-cpp&&&span class=&cm&&/*如果客户端关闭连接，则服务器也关闭对应的连接，并将用户总数减1*/&/span&
&span class=&n&&users&/span&&span class=&p&&[&/span&&span class=&n&&fds&/span&&span class=&p&&[&/span&&span class=&n&&i&/span&&span class=&p&&].&/span&&span class=&n&&fd&/span&&span class=&p&&]&/span& &span class=&o&&=&/span& &span class=&n&&users&/span&&span class=&p&&[&/span&&span class=&n&&fds&/span&&span class=&p&&[&/span&&span class=&n&&user_counter&/span&&span class=&p&&].&/span&&span class=&n&&fd&/span&&span class=&p&&];&/span&
&span class=&n&&close&/span&&span class=&p&&(&/span&&span class=&n&&fds&/span&&span class=&p&&[&/span&&span class=&n&&i&/span&&span class=&p&&].&/span&&span class=&n&&fd&/span&&span class=&p&&);&/span&
&span class=&n&&fds&/span&&span class=&p&&[&/span&&span class=&n&&i&/span&&span class=&p&&]&/span& &span class=&o&&=&/span& &span class=&n&&fds&/span&&span class=&p&&[&/span&&span class=&n&&user_counter&/span&&span class=&p&&];&/span&
&span class=&n&&i&/span&&span class=&o&&--&/span&&span class=&p&&;&/span&
&span class=&n&&user_counter&/span&&span class=&o&&--&/span&&span class=&p&&;&/span&
&span class=&n&&printf&/span&&span class=&p&&(&/span&&span class=&s&&&a client left&/span&&span class=&se&&\n&/span&&span class=&s&&&&/span&&span class=&p&&);&/span&
&/code&&/pre&&/div&&br&&b&又比如在Java中：&/b&&br&&b&在Java的阻塞编程中：通过&/b&&br&&b&&div class=&highlight&&&pre&&code class=&language-java&& &span class=&n&&ServerSocket&/span& &span class=&n&&ss&/span& &span class=&o&&=&/span& &span class=&k&&new&/span& &span class=&n&&ServerSocket&/span&&span class=&o&&(&/span&&span class=&mi&&10021&/span&&span class=&o&&);&/span&
&span class=&n&&Socket&/span& &span class=&n&&so&/span& &span class=&o&&=&/span& &span class=&n&&ss&/span&&span class=&o&&.&/span&&span class=&na&&accept&/span&&span class=&o&&();&/span&
&span class=&c1&&// 获取相关流对象&/span&
&span class=&n&&InputStream&/span& &span class=&n&&in&/span& &span class=&o&&=&/span& &span class=&n&&so&/span&&span class=&o&&.&/span&&span class=&na&&getInputStream&/span&&span class=&o&&();&/span&
&span class=&kt&&byte&/span&&span class=&o&&[]&/span& &span class=&n&&bytes&/span& &span class=&o&&=&/span& &span class=&k&&new&/span& &span class=&kt&&byte&/span&&span class=&o&&[&/span&&span class=&mi&&1024&/span&&span class=&o&&];&/span&
&span class=&kt&&int&/span& &span class=&n&&num&/span& &span class=&o&&=&/span& &span class=&n&&in&/span&&span class=&o&&.&/span&&span class=&na&&read&/span&&span class=&o&&(&/span&&span class=&n&&bytes&/span&&span class=&o&&);&/span&
&span class=&k&&if&/span&&span class=&err&&（&/span&&span class=&n&&num&/span& &span class=&o&&==&/span& &span class=&o&&-&/span&&span class=&mi&&1&/span&&span class=&err&&）&/span&&span class=&c1&&//表明读到了流的末尾，事实也就是client端断开了连接，比如调用close()&/span&
&span class=&o&&{&/span&
&span class=&n&&so&/span&&span class=&o&&.&/span&&span class=&na&&close&/span&&span class=&o&&();&/span&
&span class=&o&&}&/span&
&/code&&/pre&&/div&在Java的非阻塞编程当中：通过&/b&&br&&div class=&highlight&&&pre&&code class=&language-java&&&span class=&n&&SelectionKey&/span& &span class=&n&&key&/span& &span class=&o&&=&/span& &span class=&n&&selector&/span&&span class=&o&&.&/span&&span class=&na&&register&/span&&span class=&err&&（&/span&&span class=&n&&socketChannel&/span&&span class=&o&&,&/span&&span class=&n&&ops&/span&&span class=&o&&,&/span&&span class=&n&&handle&/span&&span class=&err&&）&/span&&span class=&o&&;&/span&
&span class=&n&&SocketChannel&/span& &span class=&n&&socketChanel&/span& &span class=&o&&=&/span& &span class=&err&&（&/span&&span class=&n&&SocketChannel&/span&&span class=&err&&）&/span&&span class=&n&&key&/span&&span class=&o&&.&/span&&span class=&na&&channel&/span&&span class=&o&&();&/span&
&span class=&n&&ByteBuffer&/span& &span class=&n&&buffer&/span& &span class=&o&&=&/span& &span class=&n&&ByteBuffer&/span&&span class=&o&&.&/span&&span class=&na&&allocate&/span&&span class=&err&&（&/span&&span class=&mi&&1024&/span&&span class=&err&&）；&/span&
&span class=&kt&&int&/span& &span class=&n&&num&/span& &span class=&o&&=&/span& &span class=&n&&socketChannel&/span&&span class=&o&&.&/span&&span class=&na&&read&/span&&span class=&o&&(&/span&&span class=&n&&buffer&/span&&span class=&o&&);&/span&
&span class=&k&&if&/span&&span class=&o&&(&/span&&span class=&n&&num&/span& &span class=&o&&==&/span& &span class=&o&&-&/span&&span class=&mi&&1&/span&&span class=&o&&)&/span&
&span class=&o&&{&/span&
&span class=&n&&key&/span&&span class=&o&&.&/span&&span class=&na&&channel&/span&&span class=&o&&().&/span&&span class=&na&&close&/span&&span class=&o&&();&/span&
&span class=&o&&}&/span&
&/code&&/pre&&/div&上述连接处理方式，返回-1也好，收到POLLERR POLLDHUP也好，都是收到了客户端的fin或者rst之后的反应，所以根据四次分手原则，我们调用close方法，发送fin给客户端。&br&&br&&br&上面这种策略通过TCP协议的返回值来得知客户端TCP断开，从而得知客户端掉线。&br&当前提是&b&如果提前根据ip或者mac做了记录&/b&，所以可以&b&在服务器端收到TCP连接中断的消息后，调用close，并且通过socket得到玩家socket数据(具体如IP地址)，从而获得user信息从而清除数据。&/b&&br&&br&&br&&b&那么这种方式有什么不完美呢？或者说有什么缺陷呢？&/b&&br&&br&&br&&b&主要原因就是TCP的断开可能有时候是不能瞬时探知的，甚至是不能探知的，也可能有很长时间的延迟，如果前端没有正常的断开TCP连接，四次握手没有发起，服务端无从得知客户端的掉线，那么就要依靠开启TCP的keep alive机制，but TCP协议的keep alive机制是不建议开启的，即使开启了默认的时间间隔是2h，泪奔！如果要服务端维持一个2h的死链接，那是可怕的，如果我们调整了时间间隔，也是有problem的，因为TCP本身就不建议TCP层的心跳检测，因为这可能导致一个完好的TCP连接在中间网络中断的情况下重启⊙▂⊙。&/b&&br&&br&&br&&b&下面有必要先介绍下TCP的keep-alive机制。&/b&&br&关于TCP自己的keep-alive机制，参看TCP/IP详解当中有如下介绍：&br&使用keeplive机制，可以检测到网络异常。&br&&b&一、什么是keepalive定时器？&br&&/b&&br&在一个空闲的（idle）TCP连接上，没有任何的数据流，许多TCP/IP的初学者都对此感到惊奇。也就是说，如果TCP连接两端没有任何一个进程在向对方发送数据，那么在这两个TCP模块之间没有任何的数据交换。你可能在其它的网络协议中发现有轮询（polling），但在TCP中它不存在。言外之意就是我们只要启动一个客户端进程，同服务器建立了TCP连接，不管你离开几小时，几天，几星期或是几个月，连接依旧存在。中间的路由器可能崩溃或者重启，电话线可能go down或者back up，只要连接两端的主机没有重启，连接依旧保持建立。&br&&br&这就可以认为不管是客户端的还是服务器端的应用程序都没有应用程序级（application-level）的定时器来探测连接的不活动状态（inactivity），从而引起任何一个应用程序的终止。然而有的时候，服务器需要知道客户端主机是否已崩溃并且关闭，或者崩溃但重启。许多实现提供了存活定时器来完成这个任务。&br&&br&存活定时器是一个包含争议的特征。许多人认为，即使需要这个特征，这种对对方的轮询也应该由应用程序来完成，而不是由TCP中实现。此外，如果两个终端系统之间的某个中间网络上有连接的暂时中断，那么存活选项（option）就能够引起两个进程间一个良好连接的终止。例如，如果正好在某个中间路由器崩溃、重启的时候发送存活探测，TCP就将会认为客户端主机已经崩溃，但事实并非如此。&br&&br&存活（keepalive）并不是TCP规范的一部分。在Host Requirements RFC罗列有不使用它的三个理由：（1）在短暂的故障期间，它们可能引起一个良好连接（good connection）被释放（dropped），（2）它们消费了不必要的宽带，（3）在以数据包计费的互联网上它们（额外）花费金钱。然而，在许多的实现中提供了存活定时器。&br&&br&一些服务器应用程序可能代表客户端占用资源，它们需要知道客户端主机是否崩溃。存活定时器可以为这些应用程序提供探测服务。Telnet服务器和Rlogin服务器的许多版本都默认提供存活选项。&br&&br&个人计算机用户使用TCP/IP协议通过Telnet登录一台主机，这是能够说明需要使用存活定时器的一个常用例子。如果某个用户在使用结束时只是关掉了电源，而没有注销（log off），那么他就留下了一个半打开（half-open）的连接。在图18.16，我们看到如何在一个半打开连接上通过发送数据，得到一个复位（reset）返回，但那是在客户端，是由客户端发送的数据。如果客户端消失，留给了服务器端半打开的连接，并且服务器又在等待客户端的数据，那么等待将永远持续下去。存活特征的目的就是在服务器端检测这种半打开连接。&br&&br&&b&二、keepalive如何工作？&/b&&br&&br&在此描述中，我们称使用存活选项的那一段为服务器，另一端为客户端。也可以在客户端设置该选项，且没有不允许这样做的理由，但通常设置在服务器。如果连接两端都需要探测对方是否消失，那么就可以在两端同时设置（比如NFS）。&br&&br&若在一个给定连接上，两小时之内无任何活动，服务器便向客户端发送一个探测段。（我们将在下面的例子中看到探测段的样子。）客户端主机必须是下列四种状态之一：&br&&br&1) 客户端主机依旧活跃（up）运行，并且从服务器可到达。从客户端TCP的正常响应，服务器知道对方仍然活跃。服务器的TCP为接下来的两小时复位存活定时器，如果在这两个小时到期之前，连接上发生应用程序的通信，则定时器重新为往下的两小时复位，并且接着交换数据。&br&&br&2) 客户端已经崩溃，或者已经关闭（down），或者正在重启过程中。在这两种情况下，它的TCP都不会响应。服务器没有收到对其发出探测的响应，并且在75秒之后超时。服务器将总共发送10个这样的探测，每个探测75秒。如果没有收到一个响应，它就认为客户端主机已经关闭并终止连接。&br&&br&3) 客户端曾经崩溃，但已经重启。这种情况下，服务器将会收到对其存活探测的响应，但该响应是一个复位，从而引起服务器对连接的终止。&br&&br&4) 客户端主机活跃运行，但从服务器不可到达。这与状态2类似，因为TCP无法区别它们两个。它所能表明的仅是未收到对其探测的回复。&br&&br&服务器不必担心客户端主机被关闭然后重启的情况（这里指的是操作员执行的正常关闭，而不是主机的崩溃）。当系统被操作员关闭时，所有的应用程序进程（也就是客户端进程）都将被终止，客户端TCP会在连接上发送一个FIN。收到这个FIN后，服务器TCP向服务器进程报告一个文件结束，以允许服务器检测这种状态。&br&&br&在第一种状态下，服务器应用程序不知道存活探测是否发生。凡事都是由TCP层处理的，存活探测对应用程序透明，直到后面2，3，4三种状态发生。在这三种状态下，通过服务器的TCP，返回给服务器应用程序错误信息。（通常服务器向网络发出一个读请求，等待客户端的数据。如果存活特征返回一个错误信息，则将该信息作为读操作的返回值返回给服务器。）在状态2，错误信息类似于“连接超时”。状态3则为“连接被对方复位”。第四种状态看起来像连接超时，或者根据是否收到与该连接相关的ICMP错误信息，而可能返回其它的错误信息。&br&&br&具体来说：&br&&p&在TCP协议的机制里面，本身的心跳包机制，也就是TCP协议中的SO_KEEPALIVE，系统默认是设置2小时的心跳频率。需要用要用setsockopt将SOL_SOCKET.SO_KEEPALIVE设置为1才是打开，并且可以设置三个参数tcp_keepalive_time/tcp_keepalive_probes/tcp_keepalive_intvl，&/p&&p&分别表示连接闲置多久开始发keepalive的ACK包、发几个ACK包不回复才当对方死了、两个ACK包之间间隔多长。&/p&&br&&p&TCP协议会向对方发一个带有ACK标志的空数据包（KeepAlive探针），对方在收到ACK包以后，如果连接一切正常，应该回复一个ACK；如果连接出现错误了（例如对方重启了，连接状态丢失），则应当回复一个RST；如果对方没有回复，服务器每隔多少时间再发ACK，如果连续多个包都被无视了，说明连接被断开了。&/p&&br&&p&“心跳检测包”是属于TCP协议底层的检测机制，上位机软件只是解析显示网口的有用数据包，收到心跳包报文属于TCP协议层的数据，一般软件不会将它直接在应用层显示出来，所以看不到。以太网中的“心跳包”可以通过“以太网抓包软件”分析TCP/IP协议层的数据流看到。报文名称”TCP Keep-Alive”。&/p&&p&一些比较可靠的以太网转串口模块，都有心跳包的检测，比如致远电子的ZNE-100TL模块，配置“心跳包检测”间隔时间设为“10”秒，使用一款”wireshark”的抓包软件来实际查看下TCP/IP协议层“心跳包”数据。&/p&&br&&br&&br&&b&看了上面的内容，使用TCP自己的keep-alive机制，也是可以实现连接维持，通过TCP传输层的心跳包探知两端TCP连接的正确性，从而得知应用层的情况（TCP在，应用一定在，TCP不在了，应用一定不在了），但是这不是最优选择！&/b&&br&&br&&br&&b&那么既然有TCP的心跳机制，我们为什么还要在应用层实现自己的心跳检测机制呢？&/b&&br&评论中 &a data-hash=&0eaae55c34dd72dee76e& href=&///people/0eaae55c34dd72dee76e& class=&member_mention& data-editable=&true& data-title=&@Raynor& data-hovercard=&p$b$0eaae55c34dd72dee76e&&@Raynor&/a& 所说：&br&tcpip详解卷1有网络异常中断的3种情况，比如os回收端口的时候发送的rst包，如果os挂了就不会发这个消息了。 另外如果网络异常，有可能收到路由器返回的icmp主机不可达消息从而关闭连接。 keepalive之所以不靠谱，是因为需要从socket error获知连接断开，而且是被动断开。 而应用层自己实现的heartbeat可以自主检测超时，更方便修改超时时间和断开前处理。&br&以及@李乐所说： &br&keepalive设计初衷清除和回收死亡时间长的连接，不适合实时性高的场合，而且它会先要求连接一定时间内没有活动，周期长，这样其实已经断开很长一段时间，没有及时性。而且keepalive好像还不能主动通知应用层，需要主动调用api去检测异常。&br&&br&&b&二：使用自己应用层的心跳包,上述方法用于正常情况下的TCP连接维护，&/b&&br&&b&&br&
场景举例如下:在游戏服务器当中，内存中维护着众多玩家的在线数据，以方便调用，比如玩家的英雄队伍信息，玩家的世界位置信息，在玩家下线的时候，服务器必须知道并且清除掉数据（不然就会出现一个已经下线的玩家出现在世界上），在上述举例中，在服务器端收到TCP连接中断的消息后，调用close，期间可以通过socket得到玩家socket数据，从而获得user信息（如果提前根据ip或者mac做了记录）从而清除数据。&/b&&br&&b&
但是如果不是正常的玩家下线，TCP的四次握手没有成功，比如网络直接中断，client端的TCP协议的fin包没有发出去，服务端就不能及时探知玩家下线，如果依赖上面讲的TCP自己的keep alive探测机制，时间较长，做不到及时处理下线玩家，并且性能不佳，因为TCP/IP的设计者本身就不支持TCP的心跳，因为这可能因为中间网络的短暂中断导致两端良好的TCP连接断开。所以一般不启用TCP的心跳机制，那我们怎么处理这些异常下线呢？如果不处理，服务端将一直维护着TCP死连接，导致网络资源（一台服务器可以支持的TCP连接有限）和内存资源（内存中可能维护着该玩家的数据）的占用，所以就要用到应用层的心跳包了&br&&/b&&br&&p&&b&下面解释下应用层的心跳包：&/b&&/p&&br&&p&心跳包，通常是客户端每隔一小段时间向服务器发送的一个数据包，通知服务器自己仍然在线，服务器与客户端之间每隔一段时间 进行一次交互,来判断这个链接是否有效，并传输一些可能有必要的数据。通常是在建立了一个TCP的socket连接后无法保证这个连接是否持续有效，这时候两边应用会通过定时发送心跳包来保证连接是有效的。因按照一定的时间间隔发送，类似于心跳，所以叫做心跳包。事实上为了保持长连接（长连接指的是建立一次TCP连接之后，就认为连接有效，利用这个连接去不断传输数据，不断开TCP连接），至于包的内容，是没有特别规定的，不过一般都是很小的包，或者只是包含包头的一个空包。&/p&&img src=&/dc34df85d63caab_b.jpg& data-rawwidth=&480& data-rawheight=&361& class=&origin_image zh-lightbox-thumb& width=&480& data-original=&/dc34df85d63caab_r.jpg&&&br&&br&&br&&br&那么心跳包的意义就在于方便的在服务端管理客户端的在线情况，并且可以防止TCP的死连接问题，避免出现长时间不在线的死链接仍然出现在服务端的管理任务中。&br&&br&再举下面一个例子说明下为什么TCP自身的四次握手断开机制不能完全保证应用程序探知连接断开从而避免死连接。&br&&p&（1）做一个游戏客户端和服务器端的测试，手动强制关闭客户端进程，然后查看服务器的情况，结果往往是，服务器收到了客户端关闭的事件。其实， 这样会忽略一个问题，没有触发异常中断事件，比如网络中断。&/p&&br&&p&（2）手动关闭客户端进程，事实上并不能测试出想要的结果，因为进程是在应用层的，所以，这种测试方法不能保证网络驱动层也不发送数据报文给服务器。经过测试会发现，当应用层强制结束进程时，对于TCP连接，驱动层会发送reset数据包！而服务器收到这个数据包就可以正常关闭了！&/p&&br&&p&（3）那么，如果网络异常甚至直接拔掉网线呢，服务器收不到这个数据包，就会导致死连接存在！&/p&&br&&p&（4）所以，心跳包是必要的，或者使用TCP协议本身的Keep-alive来设置（但是keep-alive不够好）&/p&&br&&p& 我们不能误解TCP连接如同一条绳子，一方断开了，另外一方必然会知道的。事实上TCP连接，这个“面向连接”的物理连接并不存在，它只是抽象出来的概念，是一个虚拟的连接，对于物理层，对于网线、光纤而言，不存在连接不连接的概念，因为，对它们而言，无非就是一些电流脉冲而已，具体就是一个一个的IP报文。&/p&&br&&p& TCP的连接，不过是通过ACK、SEQ这些机制来模拟实现的，具体比如差错重传，拥塞控制&/p&&br&&br&&br&&p&那么心跳包的检测发送处理对服务器资源的耗费怎么判断?&/p&&p&这个要看心跳包发送的频率，我们可以自行设置&/p&&br&&p&另外这里有个例程，模拟了socket心跳包的C语言实现：&/p&&p&&a href=&///?target=http%3A//m.blog.csdn.net/blog/mfye1& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Socket心跳包异常检测的C语言实现，服务器与客户端代码案例&i class=&icon-external&&&/i&&/a&&/p&
游戏服务器常常有心跳包的设计。 我们的心跳包就是为了防止Socket断开连接，或是TCP的连接断开吗？ 答案是否定的，TCP连接的通道是个虚拟的，连接的维持靠的是两端TCP软件对连接状态的维护。TCP 连接自身有维护连接的机制，说白了就是自身有长时间没有数据…
题主说的钱，我理解为就是余额，所以我认为题主问的就是卡余额是保存在什么地方。&br&&br&卡余额可能保存在卡里，也可能保存在服务器上，具体情况是两种都有。&br&&br&&b&1. 余额只保存在卡内&/b&&br&&br&应用范围：磁条银行卡在过去曾经广泛使用，现在几乎没有。&br&&br&这种方式安全性很差，但出现的最早，因为过去的时候网络实时验证还很不成熟，只好把余额数字放到卡里（小说《白夜行》里有类似的记述，直接克隆卡，修改卡余额就能取钱），这种模式对账周期一般比较长（可能是以月甚至更长时间计算），因为安全性的问题已经基本淘汰。&br&&br&卡会长期放在用户手里，很难保证不被破解，再强大的算法也无法保证长时间的可靠性，而且由于计算能力的不断提升，任何早期的算法放到今天都是不一定可靠的。尤其是磁性卡片，被破解基本上是时间问题。&br&&br&虽然目前CPU卡已经十分安全，但也不能保证未来5-10年这种技术仍然是可靠的。而且老卡的淘汰也需要一段时间。&br&&br&&b&2. 余额只保存在服务器上，卡只作为身份标识&/b&&br&&br&应用范围：几乎全部的银行卡（磁条卡）、电话卡，大部分的校园卡、饭卡。&br&&br&银行卡里面是没有余额的，甚至连密码都没有保存，很多银行卡里保存的都是卡的信息（其实就是卡号），ATM机或者POS机在刷卡时读取卡号，等待用户密码，然后把这些都打包给服务器去验证。&br&&br&所以ATM机和POS机都是需要联网的。有人说POS机可以不联网，那是因为POS机里内置了一个SIM卡，通过类似手机上网的功能完成拨号、发送、接受数据的操作。&br&&br&校园卡、饭卡也是类似的，这些卡的刷卡终端大部分都需要联网，见过很多学校的食堂因为网络故障导致无法刷卡的。&br&&br&这种方式的好处就是很安全，卡内的信息就算是被破解了也无法修改账户余额，缺点就是无法离线使用，而且要查询余额也很麻烦。&br&&br&&b&3. 余额同时保存在服务器和卡内&/b&&br&&br&应用范围：大部分公交卡，部分校园卡、饭卡、IC卡电子钱包等。&br&&br&公交卡里是有余额的，比如题主贴出的北京公交卡，公交卡与其它卡片不同的地方是刷卡的反应速度需要很快，如果公交卡要联网验证，那么速度就太慢了，所以公交卡里必须要有余额以保证快速刷卡。&br&&br&但这样做安全性就有问题了，所以当公交卡的刷卡终端是有线网络时，实时联网验证，并同步一下余额是否正确，如果刷卡终端是离线的，则把刷卡信息同时保存在卡里和刷卡终端上，刷卡终端每天晚上结算的时候联网统一结算。&br&&br&所以，&b&对于北京的公交卡来说&/b&：&br&&br&如果是在超市内刷卡结账，这些结算都是实时与服务器验证的，如果发现余额异常，则刷卡会失败。&br&&br&如果是在公交卡上刷卡，结算是非实时的，换句话说，如果伪造、篡改公交卡里的余额，当天坐公交车是没有问题的，并且由于公交车结算时间是每天晚上收车以后，在结算之前，伪造的余额是不会被发现的，但结算以后可能会被人发现。&br&&br&刷地铁是否是实时结算还不清楚，&b&可能是&/b&实时结算的，其它的应用场景如用IC卡打电话是否是实时计算也不是太清楚，有了解情况的可以来说说。&br&&br&也就是说显示的余额确实是卡里的，但交易过程如果是联网的，那么会二次验证余额。&br&&br&有一个方法可以比较简单的验证公交卡是否是实时交易：大部分城市的公交卡都能在网上查询实时余额（至少北京的支持），刷一次公交卡，到网上查询一下，如果记录能对的上，那么交易是实时的，如果记录对不上，交易则不是实时的。&br&&br&---------------------------------------------------------------------------------------------------------&br&&br&当然了，别以为通过服务器验证就是安全的：&br&&br&服务器漏洞被入侵，卡内被非法充值：&a href=&///?target=http%3A///it//3355711.shtml& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&奇虎360员工入侵公交一卡通――中新网&i class=&icon-external&&&/i&&/a&&br&&br&把普通公交卡改成员工卡（可以无限制进出地铁站）：&a href=&///?target=http%3A///thread--1.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&高管破解北京公交卡非法充值消费400余次被公诉&i class=&icon-external&&&/i&&/a&&br&&br&因为北京目前旧卡（非CPU卡）仍然能使用，所以会有克隆卡：&a href=&///?target=http%3A////14/45.htm& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&千龙网--北京--售用克隆公交卡 北京一男子涉嫌盗窃被捕&i class=&icon-external&&&/i&&/a&
题主说的钱，我理解为就是余额，所以我认为题主问的就是卡余额是保存在什么地方。 卡余额可能保存在卡里，也可能保存在服务器上，具体情况是两种都有。 1. 余额只保存在卡内 应用范围：磁条银行卡在过去曾经广泛使用，现在几乎没有。 这种方式安全性很差，…
Servlet（Server Applet），全称Java Servlet，未有中文译文。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况下，人们将Servlet理解为后者。&br&&br&Servlet运行于支持Java的应用服务器中。从实现上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。&br&&br&最早支持Servlet标准的是JavaSoft的Java Web Server。此后，一些其它的基于Java的Web服务器开始支持标准的Servlet。&br&&br&&b&Servlet编程需要使用到javax.servlet
和 javax.servlet.http两个包下面的类和接口，在所有的类和接口中，javax.servlet.servlet 接口最为重要。所有的servlet程序都必须实现该接口或者继承实现了该接口的类。&/b&&br&&p&javax.servlet.ServletC&br&javax.servlet.ServletE&br&javax.servlet.http.HttpS&br&javax.servlet.http.HttpServletR&br&javax.servlet.http.HttpServletR&/p&&p&javax.servlet.http.HttpS&/p&&p&javax.servlet.http.C&/p&&p&javax.servlet.ServletC&/p&&p&javax.servlet.GenericS&br&&/p&&p&以上是Servlet的主要类和接口&/p&&br&&p&&b&(1) javax.servlet.S//Servlet接口&/b&&/p&&p&拥有方法：&/p&&p&//该函数用于初始化该servlet 该函数只是会被调用一次， 当用户第一次访问该servlet的时候被调用&/p&&p&&b&public void init(ServletConfig parm1) throws ServletException&/b&&/p&&p&// //用于得到servlet配置文件 与生命周期无关&/p&&p&&b&public ServletConfig getServletConfig() &/b&&/p&&p&// service 函数用于处理业务逻辑&/p&&p&//程序员应当把业务逻辑代码写在这里&/p&&p&//该函数在用户每次访问servlet的时候都会被调用&/p&&p&//ServletRequest 对象用于获得客户端信息，ServletResponse 对象用于向客户端返回信息（客户端可以理解为浏览器）&/p&&p&public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException &/p&&p&public String getServletInfo() &/p&&p&&b& //销毁servlet实例（释放内存）&/b&&/p&&p&&b&//1 reload 该servlet(webApp)&/b&&/p&&p&&b&//2 关闭Tomcat 或者说 关机之后 都会调用这个函数 &/b&&/p&&p&public void destroy() &/p&&br&&br&&br&&p&--------------------------分割线 日------------------------------&/p&&p&&b&Servlet运行于支持Java的应用服务器中。从实现上讲，Servlet可以响应任何类型的请求，但绝大多数情况下Servlet只用来扩展基于HTTP协议的Web服务器。&/b&&br&&/p&&p&&b&对这句话再做点解释，比如HttpServlet类继承自Servlet类，可以利用继承HttpServlet来实现Http请求，当不是Http请求的时候，也可以定义其他形式的Servlet。&/b&&/p&&br&&br&&p&&b&比如我之前工作过的一个公司的架构就是使用Servlet来处理自己的应用层协议。&/b&&/p&&p&&b&-----------------------------------------------------------------------------------------------&/b&&/p&&p&&b&下面是我曾经做过的Servlet笔记&/b&&/p&&br&&p&&b&Servlet体系结构&/b&&/p&&p&servlet首先是一个接口,GenerivServlet呢实现了这个接口。&/p&&p&他们都是属于javax.servlet.*;的这个包里面的&/p&&p&此外，在javax.servlet.http*;的这个包里面呢，其实也含有一个重要的servlet类叫httpServlet&/p&&br&&p&首先我们看到ie浏览器，我们讲servlet也好，讲jsp也罢，首先我们要明确的是这是一个bs的体系结构，所以说他必然有浏览器的，那么浏览器要去访问Tomcat其中的某一个servlet或者说是jsp的时候呢，必须在ie浏览器当中输入&/p&&div class=&highlight&&&pre&&code class=&language-text&&http://........
&/code&&/pre&&/div&&p&之类的命令敲了回车键之后浏览器就会向你指定的Tomcat发送http请求的，这个请求会被Tomcat的Web服务器的这个模块接收，web服务器处理之后呢会转发给Tomcat的容器部分进行处理，他会帮助ie浏览器找到这个请求想要找到的servlet，这时呢在容器里面的行为要么是在容器内再向数据库发送操作数据库的命令，要么呢直接返回结果 ，其实就是静态的html页面，当页面被web服务器模块接收到之后呢，他会将静态页面返回给那个发送请求的那个ie浏览器，ie浏览器得到这个结果之后呢，就会自己显示出来，然后用户就能看到结果，所以可以将我们的结果分成三个部分，第一个部分是ie浏览器，第二个呢是Tomcat模块，第三个呢就是数据库模块。&/p&&br&&p&其实开发servlet有三种方法，一种是实现servlet接口，一种是继承GernericServlet
还有一种是继承HttpServlet。
为什么会有三种方法呢？因为这个servlet这个技术并不是说一出现之后就是成熟的，他经历过这三个发展的阶段，因此它具有这三种方式，其实在最先前是实现servlet接口方法来开发的，后面的时候技术人员发现这样写似乎不太方便，所以又发展出来一个叫做继承GenericServlet的方法来实现，后来又发现这个也不是很方便，所以呢又发展出来了继承 HttpServevlet方式来实现&/p&&p&为了使学习更加深刻，我会把三种方式都实现下。&/p&&p&Servlet开发是很简单的事情特别是用一些高级工具来开发的话，特别是像JBuilder来实现的话只要点一下就行了，但很遗憾的这样的高级工具他会隐藏太多的细节，这样的话就不利于我们的学习，特别是部署之类的他就给你全写了，那么你就不好学到他servlet的底层运行机制和原理，为了让大家理解的更为深刻，我还是先用JCreater来实现开发Servlet，后面当然会用到eclipse 或者JBuilder这些高级工具来开发。我们先过一点苦日子，然后再过一点好日子，这样的话知识更加扎实一点了。&/p&&p&下面我们就来真正的来开发Servlet，首先用什么方法呢？用实现接口的方法来实现&/p&&p&在这里呢会引入servlet的生命周期这个特点。这第一个servlet非常简单，就是写一个Hello World 在浏览器中输出。教程依照先简单，再难，再综合的顺序进行。&/p&&p&下面是Servlet的开发流程。&/p&&p&1：首先在Tomcat的主目录下的webapp下面建立一个WEB-INF文件夹 &/p&&p&2：然后再WEB-INF文件夹下建立一个web.xml文件,记录网站的配置信息 &/p&&p&
建立classes子文件夹 存放你的servlet&/p&&p&
当然这个操作你可以自己完成 也可以在root目录下拷贝一份 &/p&&p&大家可以看到 这个地方传递过来了一个信息，什么信息呢？&/p&&br&&p&对于Tomcat来讲，你所有的这些网站，页面对他来讲都是web应用，他看来就是web应用,就是在webapp下面建立我们的网站。&/p&&br&&p&比如建立一个文件夹叫做mywebsite,接下来文件夹中放什么东西呢，我们要放的就是WEB-INF文件夹，在里面放置web.xml文件以及classes文件夹和lib文件夹。&/p&&br&&p&WEB-INF这个要注意大小写，要注意大小写要一模一样才行的，名字都要一样才行的。&/p&&br&&p&在这个文件夹下进行上述两种操作，你可能会去问，为什么要这样做呢？这个倒是没有办法的事情 因为这就是规范。&/p&&br&&p&classes当然是存servlet用的 ，那个lib文件夹用来做什么呢？&/p&&br&&p&用来存放这个应用汇用到的一些jar包，比如数据库啦之类的，文件的下载要用的包都放在lib里面去，就是lib库。&/p&&div class=&highlight&&&pre&&code class=&language-text&&//这是我的第一个Servlet 使用实现Servlet接口的方式来开发
package com.
import java.io.IOE
import java.io.PrintW
import javax.servlet.S
import javax.servlet.ServletC
import javax.servlet.ServletE
import javax.servlet.ServletR
import javax.servlet.ServletR
public class Hello implements Servlet
// 该函数用于初始化该servlet， 类似于我们的类的构造函数
// 该函数只是会被调用一次， 当用户第一次访问该servlet的时候被调用
public void init(ServletConfig parm1) throws ServletException
System.out.println(&init it !&);
// 用于得到servlet配置文件 与生命周期无关
public ServletConfig getServletConfig()
// service 函数用于处理业务逻辑
// 程序员应当把业务逻辑代码写在这里
// 该函数在用户每次访问servlet的时候都会被调用
// ServletRequest 对象用于获得客户端信息，ServletResponse 对象用于向客户端返回信息（客户端可以理解为浏览器）
// servelt jsp b/s
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException
System.out.println(&service it&);
PrintWriter pw = res.getWriter();
pw.println(&hello world&);
public String getServletInfo()
return & &;
// 销毁servlet实例（释放内存）
// 1 reload 该servlet(webApp)
// 2 关闭Tomcat 或者说 关机之后 都会调用这个函数
public void destroy()
System.out.println(&destory it&);
&/code&&/pre&&/div&&p&以上就是实现servlet接口的方式来开发servlet方式来代码实现 &/p&&p&其实以上方法都是回调函数
都是会在特定的时候特定的环境下自动调用的&/p&&p&其中iinit() 和 destroy() 都是只会调用一次的
会在每一次都会被调用的&/p&&br&&p&到现在还没有完成
因为如果你想让别人访问到你的wervlet 的话 你就要部署你servlet&/p&&p&下面讲授关于部署servlet的步骤（在web.xml 进行配置设置）&/p&&p&如果你要问为什么进行部署，那么还是一句话，规范。&/p&&div class=&highlight&&&pre&&code class=&language-text&&&servlet&
&!--给你的servlet起名字，任意的--&
&servlet-name&hello_servlet&/servlet-name&
&!--指明servlet的路径，包名+类名 注意类名后不能加上java--&
&servlet-class&com.tsinghua.Hello&/servlet-class&
&/servlet&
&servlet-mapping&
&!--mapping
自然就是映射了
于是乎 这个同上,一致--&
&servlet-name&hello_servlet&/servlet-name&
&!--这是浏览器中输入的访问该servlet的url 任意的--&
&url-pattern&/sp&/url-pattern&
&/servlet-mapping&
&/code&&/pre&&/div&用下面的控制台命令编译Hello.java之后，我们就可以启动Tomcat来进行访问了&br&&img src=&/130b7fad94bdf75f23805fd_b.png& data-rawwidth=&1122& data-rawheight=&57& class=&origin_image zh-lightbox-thumb& width=&1122& data-original=&/130b7fad94bdf75f23805fd_r.png&&&img src=&/d0eea573a4b52d41b3e2306d_b.png& data-rawwidth=&642& data-rawheight=&352& class=&origin_image zh-lightbox-thumb& width=&642& data-original=&/d0eea573a4b52d41b3e2306d_r.png&&启动Tomcat的bin目录下的startup.bat之后，&br&输入&div class=&highlight&&&pre&&code class=&language-text&&http://127.0.0.1:8080/guowuxin/sp
&/code&&/pre&&/div&&br&&img src=&/cb4b4a3f9b870d57ae8e0_b.png& data-rawwidth=&405& data-rawheight=&61& class=&content_image& width=&405&&&br&多次访问之后就能体会到Servlet的生命周期&br&&img src=&/6d401fbc2b1_b.png& data-rawwidth=&462& data-rawheight=&128& class=&origin_image zh-lightbox-thumb& width=&462& data-original=&/6d401fbc2b1_r.png&&&br&访问结果&br&&img src=&/c6994aaf18d56f9e1bc87fa9c7ff500e_b.png& data-rawwidth=&487& data-rawheight=&86& class=&origin_image zh-lightbox-thumb& width=&487& data-original=&/c6994aaf18d56f9e1bc87fa9c7ff500e_r.png&&
Servlet（Server Applet），全称Java Servlet，未有中文译文。是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。狭义的Servlet是指Java语言实现的一个接口，广义的Servlet是指任何实现了这个Servlet接口的类，一般情况…
&p&下面是我一朋友想要学习openstack，我给他列的一个学习清单，希望对你有所帮助
OpenStack search: &a href=&///?target=https%3A//www.openstack.org& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://www.&/span&&span class=&visible&&openstack.org&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a& (search 框)&/p&&p&
openstack资源整理： &a href=&///?target=http%3A//blog.csdn.net/workdog/article/details/8246914& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&OpenStack资源整理（转自陈沙克）&i class=&icon-external&&&/i&&/a&&/p&&p&
OpenStack官方博客： &a href=&///?target=http%3A//www.openstack.org/blog/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&The OpenStack Blog&i class=&icon-external&&&/i&&/a&&/p&&p&
源码： &a href=&///?target=https%3A///openstack& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&openstack (OpenStack) 路 GitHub&i class=&icon-external&&&/i&&/a&&/p&&p& IBM openstack： &a href=&///?target=http%3A///developerworks/cn/views/cloud/libraryview.jsp%3Fsort_by%3D%26show_abstract%3Dtrue%26show_all%3D%26search_flag%3D%26contentarea_by%3DCloud%2Bcomputing%26search_by%3Dopenstack%26product_by%3D-1%26topic_by%3D-1%26type_by%3D%25E6%E6%259C%%25B1%25BB%25E5%2588%25AB%26ibm-search%3D%25E6%E7%25B4%25A2& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&IBM developerWorks 中国 : Cloud computing : 文档库&i class=&icon-external&&&/i&&/a& &a href=&///?target=http%3A///developerworks/cn/views/cloud/libraryview.jsp%3Fsort_by%3D%26show_abstract%3Dtrue%26show_all%3D%26search_flag%3D%26contentarea_by%3DCloud%2Bcomputing%26search_by%3Dopenstack%26product_by%3D-1%26topic_by%3D-1%26type_by%3D%25E6%E6%259C%%25B1%25BB%25E5%2588%25AB%26ibm-search%3D%25E6%E7%25B4%25A2& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&IBM developerWorks 中国 : Cloud computing : 文档库&i class=&icon-external&&&/i&&/a&&a href=&///?target=http%3A///developerworks/cn/views/cloud/libraryview.jsp%3Fsort_by%3D%26show_abstract%3Dtrue%26show_all%3D%26search_flag%3D%26contentarea_by%3DCloud%2Bcomputing%26search_by%3Dopenstack%26product_by%3D-1%26topic_by%3D-1%26type_by%3D%25E6%E6%259C%%25B1%25BB%25E5%2588%25AB%26ibm-search%3D%25E6%E7%25B4%25A2& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&sort_by=&show_abstract=true&show_all=&search_flag=&contentarea_by=Cloud+computing&search_by=openstack&product_by=-1&topic_by=-1&type_by=%E6%89%80%E6%9C%89%E7%B1%BB%E5%88%AB&ibm-search=%E6%90%9C%E7%B4%A2&i class=&icon-external&&&/i&&/a&
陈沙克： &a href=&///?target=http%3A///tag/openstack/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&openstack&i class=&icon-external&&&/i&&/a&
quqi99： &a href=&///?target=http%3A//blog.csdn.net/quqi99/article/details/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&如何学习OpenStack与精通OpenStack好书推荐 ( by quqi99 )&i class=&icon-external&&&/i&&/a&
&a href=&///?target=http%3A//blog.csdn.net/lynn_kong/article/details/8829236& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&【OpenStack】学习OpenStack的历程--送给初学者&i class=&icon-external&&&/i&&/a&
Unitedstack: &a href=&///?target=http%3A///blog/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&博客 - UnitedStack&i class=&icon-external&&&/i&&/a&
OpenStack 源码解读及相关：
&a href=&///?target=http%3A//yansu.org//learn-python-stevedore-module-in-detail.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&学习Python动态扩展包stevedore&i class=&icon-external&&&/i&&/a&&/p&&br&&p&进阶：&/p&&p&
OpenStack 管理员手册： &a href=&///?target=http%3A//docs.openstack.org/admin-guide-cloud/content/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&OpenStack Docs: OpenStack Cloud Administrator Guide&i class=&icon-external&&&/i&&/a&&/p&&p&
OpenStack 开发手册：
&a href=&///?target=http%3A//docs.openstack.org/developer/openstack-projects.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&OpenStack Docs: Developers&i class=&icon-external&&&/i&&/a&&/p&&p&
HowTo Contribute： &a href=&///?target=https%3A//wiki.openstack.org/wiki/How_To_Contribute& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&How To Contribut&i class=&icon-external&&&/i&&/a&e&/p&&p&终极：&/p&&p&
1. 官网 + WIKI： &a href=&///?target=http%3A//www.openstack.org/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Home >> OpenStack Open Source Cloud Computing Software&i class=&icon-external&&&/i&&/a&&/p&&p&
2. 邮件列表： &a href=&///?target=https%3A//wiki.openstack.org/wiki/Mailing_Lists& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Mailing Lists&i class=&icon-external&&&/i&&/a&&/p&&p&
3. 源码： &a href=&///?target=https%3A///openstack& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&openstack (OpenStack) 路 GitHub&i class=&icon-external&&&/i&&/a&&/p&&p&
4. bugs， features， QA： &a href=&///?target=https%3A//launchpad.net/openstack& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&OpenStack in Launchpad&i class=&icon-external&&&/i&&/a&
（选择合适的子项目 （Projects））&/p&&p&
5. 代码审核： &a href=&///?target=https%3A//review.openstack.org/%23/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Gerrit Code Review&i class=&icon-external&&&/i&&/a&&/p&&p&
文档库： &a href=&///?target=http%3A//docs.openstack.org/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&OpenStack Docs: Current&i class=&icon-external&&&/i&&/a&&/p&&p&
&a href=&///?target=https%3A//wiki.openstack.org/wiki/UsingIRC& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&UsingIRC - OpenStack&i class=&icon-external&&&/i&&/a&&/p&&p&&a href=&///?target=https%3A//wiki.openstack.org/wiki/IRC& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&IRC - OpenStack&i class=&icon-external&&&/i&&/a&&/p&&p&
8. OpenStack会 + IRC： &a href=&///?target=https%3A//wiki.openstack.org/wiki/Meetings& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Meetings - OpenStack&i class=&icon-external&&&/i&&/a&&/p&&p&9. Codes statistics: &a href=&///?target=http%3A///& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&&/p&
下面是我一朋友想要学习openstack，我给他列的一个学习清单，希望对你有所帮助
博客： OpenStack search:
(search 框) openstack资源整理：
OpenStack官方博客：
&p&服务器之所以可以不关机，是因为人类不会经常操作他，就算操作他也是为了一些跟自己的娱乐无关的项目，这样就不会经常把机器搞坏（当然不能因此掉以轻心）。这跟硬件没关系，台式机和服务器的硬件都是差不多的，这只跟人类物种的劣根性有关（逃&/p&&p&所以机器要总是重启，其实是你自己滥用它，譬如说安装那些明显就干过坏事的软件，见到UAC毫不犹豫就给了Yes也不调查一番。服务器安装的软件，只要你好好按照公司的规章制度，那么都已经被其他的五百万台服务器验证过了，基本不会出事。&/p&&p&我自己在公司用的台式机，因为只装Visual Studio，都是几个月不关机用到被IT scheduler了一个强制系统更新为止。自己家的电脑还额外装了QQ、微信、Steam和Hyper-V，都是久经考验的软件，没有问题。题主要是也能做到除了IE、QQ和Steam（或者战网）以外什么都不用，网页看完了立刻关掉（而不是留几百个tab），你也不用关机。这个要求是很合理的，一个正常人的所有PC娱乐活动都能被这三个软件完全覆盖。当然对IE的使用，并不包含下载其他软件这个动作。&/p&&p&不过我在家睡觉的时候还是把机器关了，因为天知道这些美帝老房子的电线怎么样，烧了就破产了（逃&/p&
服务器之所以可以不关机，是因为人类不会经常操作他，就算操作他也是为了一些跟自己的娱乐无关的项目，这样就不会经常把机器搞坏（当然不能因此掉以轻心）。这跟硬件没关系，台式机和服务器的硬件都是差不多的，这只跟人类物种的劣根性有关（逃所以机器要总…
Sphinx是我的博士论文，当时CMU主流团队叫做Angel，Sphinx开始时，就是我一个人做的。后来，洪小文刚进入博士班，帮着我做，有些code是他写的。论文里的想法、实验都是我自己做的，但是因为洪小文有贡献，所以在后来出版的一些文章上，除了我和导师的名字，我也有挂他的名字。&br&&br&毕业后，Sphinx被立项成为CMU主流，我负责这个项目两年，黄学东是我雇佣的博士后，另外有三、四位成员，包括洪小文。&br&&br&两年后，我离开CMU，加入苹果，黄学东成为这个项目的负责人。&br&&br&在这件事情上，不要想太多，大家说的都没有错误。Sphinx既是我的博士论文，也是后来组织的名称。
Sphinx是我的博士论文，当时CMU主流团队叫做Angel，Sphinx开始时，就是我一个人做的。后来，洪小文刚进入博士班，帮着我做，有些code是他写的。论文里的想法、实验都是我自己做的，但是因为洪小文有贡献，所以在后来出版的一些文章上，除了我和导师的名字，…
&p&fb的license是隐藏的坑。好几年前在一些技术会议上遇到fb来的工程师，我就问过他们，他们表示这个是针对某些（中国）公司的防御性条款。当时我就觉得这套说辞有问题，不过对方都是搞技术的工程师，对法务事项也没有责任/权限，就没有追问。&/p&&p&说起来，小公司也许是无所谓的，但国内大公司也用React确实是存在一定风险的，如果法务仔细看过条款肯定都不会同意的。从这个角度说，Apache的举措是非常正常的。&/p&
fb的license是隐藏的坑。好几年前在一些技术会议上遇到fb来的工程师，我就问过他们，他们表示这个是针对某些（中国）公司的防御性条款。当时我就觉得这套说辞有问题，不过对方都是搞技术的工程师，对法务事项也没有责任/权限，就没有追问。说起来，小公司也…
TCP拥塞控制算法造成的。这个机制叫做slow start。&br&&br&&a href=&///?target=https%3A//en.wikipedia.org/wiki/TCP_congestion_control%23Slow_start& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&TCP congestion control&i class=&icon-external&&&/i&&/a&&br&&a href=&///?target=http%3A//packetlife.net/blog/2011/jul/5/tcp-slow-start/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&TCP Slow Start&i class=&icon-external&&&/i&&/a&&br&&br&&br&简单说，当用户向服务器建立连接时，没人知道两者之间有效带宽能有多大——可能是1G的光纤，也可能是坑爹的2G手机网络……&br&&br&可采用的策略无非两种：&br&一是默认链路速率很大，一开始用能支持的最大流量发；发现对方接不过来再尝试更小的流量；&br&二是默认链路速率很小，用最低流量发；发完发现对方响应很快、没有丢包，就尝试加大速率发；没丢再加大；若出现拥塞，切换到拥塞控制算法继续尝试，直到找到链路允许的最大速率（具体做法较为复杂，有很多种算法。不同算法适应的网络也颇有不同；而且还一直在增加更新更好的算法）。&br&&br&前者容易造成资源浪费，万一存在网络攻击还会急剧放大攻击的威胁能力；后者就好的多。&br&&br&不要被slow start这个名字给误导了，它的意思是从低速开始试探流量，并不是“慢慢增加下载速率”。其实相关算法要求尽快探明链路速率上限、同时还能应对各种意外情况方为最佳。&br&&br&&br&——————————————————————————&br&&br&想说清楚slow start的精确过程并不容易，需要很多基础知识。&br&&br&首先我们知道，TCP是“保证数据依序正确到达”的通信协议。换句话说，它不能像UDP那样，一个报文发出去就完事，不管对方有没有收到、或者是什么时候收到的；相反，它要保证报文被对方收到、且内容不出错、顺序也不出错。&br&&br&要保证这个，那么至少就必须在本地拷贝一份报文；万一对方没收到，就利用本地备份重传。不然难道你能告诉用户：先别发你的第22997个字节，我把你的第21886个字节弄丢了，你能再发一次吗？&br&&br&同样的，既然需要知道对方有没有收到，那么对方在收到数据后，就需要签一张收条——术语叫ACK（&a href=&///?target=https%3A//en.wikipedia.org/wiki/Acknowledgement_%28data_networks%29& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Acknowledgement (data networks)&i class=&icon-external&&&/i&&/a&）；只有拿到对方的收条了，才可以在缓冲区中删除那段数据（从发包、到接到ACK，这个时间就叫做&a href=&///?target=https%3A//en.wikipedia.org/wiki/Round-trip_delay_time& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Round-trip delay time&i class=&icon-external&&&/i&&/a&，简称RTT。其实你理解成ping值也可以，原理是一样的）。&br&&br&不仅如此，前面提到过，TCP要保证“数据顺序”；如果第11886个字节还没收到、第32700个字节已经发了；两者之间的数据已经超过缓冲区大小了，这第11886个字节还怎么“按顺序”返回给用户？&br&&br&所以，用户一次最多允许发“缓冲区大小”个数据；超出就会提示socket忙；只有最前面开始的顺序N个字节已经收到ACK的时候，才可以再发N个字节出去。&br&&br&这个“缓冲区”，术语就叫“TCP window”（&a href=&///?target=https%3A//en.wikipedia.org/wiki/TCP_congestion_control%23Congestion_window& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&TCP congestion control&i class=&icon-external&&&/i&&/a&）；其中，收发两个方向的TCP windows size是彼此独立的；通信双方还可以在每个方向上协商TCP window的大小（事实上，每个方向上还区分为发送者的cwnd和接收者的rwnd，两者大小也不总是相等的）。&br&&br&正因为必须头部的连续若干字节成功发送并收到ACK才可以删除它、然后往后续N个字节的内容，这就使得TCP Window看起来好像在一系列数据上面“滑动”：经过确认的数据从一端“滑”出窗口，更多的新数据才可以从另一端“滑”入窗口。这就是著名的“滑窗算法”。&br&&br&&br&基于滑窗算法的特点，再考虑数据发出到收到ACK所需的时间（RTT），链路速率上限大约为：&br&（TCP window size） / RTT&br&&br&可见，只要控制住了TCP window的大小，也就控制住了数据传输速率。&br&&br&&br&过去，TCP window size最大值为65535字节；那么若线路ping值为100ms，则最大传输速率为：ms，即大约0.624M字节每秒。&br&&br&这个TCP window size的限制，在现在越来越“疯狂”的网络带宽面前、尤其是在跨海电缆/卫星通信等高延迟领域，已经越来越力不从心了。所以后来的RFC1323允许缩放TCP window，最高可达1G。&br&&br&这里有更为详细的讨论：&br&&a href=&///?target=https%3A///zh-cn/magazine/2007.01.cableguy.aspx& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&The Cable Guy: TCP Receive Window Auto-Tuning&i class=&icon-external&&&/i&&/a&&br&&br&&br&&br&回到原问题上。&br&&br&如果一开始就使用最大的TCP window size（按旧时的64K计算），那么：&br&1、如果有人攻击你，开许多许多链接但并不传输数据；那么他开1000个链接，哪怕仅考虑一个发送缓冲区，你也得支付64M内存；他弄1000台肉鸡每台开1000个链接，你就至少得能轻易分配64G内存才顶得住——面对现在黑客们动辄控制十万计肉鸡的现实，这就是分分钟死在协议层的节奏。&br&2、链路中的其他设备要替你转发数据包；如果对方接收不及，这些数据就会拥塞在链路中间的交换机/路由器等设备上；如果它们的缓冲队列满了，就会丢弃后续的数据包；然后你就需要大量重传数据了——这样不仅浪费流量，而且重传还是一个很重要的、借以调整网络参数的指标；这种无意义的重传肯定会打乱设备上的各种参数，从而需要更复杂的算法和更长的时间，才能重新稳定网络。&br&&br&所以，这里才需要slow start这个机制，从极小的TCP window size开始尝试（1、2、10等）。&br&&br&尝试机制大概是：每收到一个ACK包，就把TCP window size加1；那么理论上，一个RTT周期内，TCP window size就会翻倍（但协议允许接收者延迟发送ACK——类似用一个ACK表示“从上次确认的序号9开始，直到15号均已收到”；所以一个RTT后，TCP window size未必一定能准确的翻倍）。&br&&br&（请注意：TCP window size是&b&以字节为单位&/b&的；这个玩意儿和每次发出的数据包大小是&b&脱钩&/b&的。或者说，你往socket里一次写1个字节，未必就会对应一个数据包；往socket一次写40960个字节，那么肯定不会一起放在一个数据包里给你一次发出去；ACK是每若干个包[实际是一到两个]返回一次，但这一次相当于对相关包中的所有字节都做了ACK。这里可参考TCP Nagle算法以及MTU相关资料加强理解。因为这些和主题相关性不大，就不展开了）。&br&&br&&br&前面提到过，链路传输速率的理论上限 = TCP window size / RTT；那么TCP window size翻倍就相当于链路传输速率翻倍了。&br&但是，不同网络的RTT是不同的。如果你的网络延迟是100ms，那么你的初始传输速率自然就是4ms网络的1/25，然后你还需要100ms的时间（4ms延迟网络的25倍）、才能让传输速率增加一倍！&br&&br&另一个方面，当你的网络响应极慢（100ms）时，达到同样的传输速率，你的TCP window size反而要比响应快的网络大若干倍（比如，可能比4ms的网络大25倍）。&br&&br&或者，如果网络中间某个地方做了限速，那么它就会采用一定的算法来防止你短时间发送太多的数据；这些算法往往会用到缓冲区；这些缓冲区的存在也会影响到RTT（当发送速度接近限速上限时，数据就可能在缓冲区滞留更久）——你的机器可能同时发出了几十、几百甚至几千个TCP链接，这些链接都会争抢带宽；有的时候，你的机器还需要和另外许多台设备争用网络，这都可能造成RTT增大。&br&&br&&br&所以你看，slow start算法其实很“鸡贼”的：它利用网络本身的特性（RTT）来为不同用户提供不同的基础传输速率和不同的传输速率增加速度——这很容易理解，ping值大的机器要么距离很远、要么和很多机器争夺不大的出口带宽：所以“基于RTT的歧视”自然而然就达到了“依据对方网络状况定制传输速率调整方案”的效果。&br&&br&换句话说，slow start是通过线性增加TCP window size和利用网络本身的RTT来“被动限速”的；所以对不同网络，初始传输速率是变量、每秒增加的传输速率也是变量——从时间上看，的确是每个RTT周期增长一倍传输速率的“指数率增长”；但从细节上看，它其实是随着每个ACK包平滑增加传输速率（根本上说，这个算法压根就不知道何谓“传输速率”，它只是在尽量快速的扩大TCP windows size而已：窗口大小配合链路本身的RTT，自然形成了某种事实上的限速机制）。&br&&br&&br&特别需要注意的是：这里有个细节，就是TCP window size每加1，都需要一个来自接收者的ACK为前提，&b&并不是盲目累加的&/b&。&br&&br&所以这里可不是什么简单的“（每周期）流量加倍”——那样从盲目加大流量、到发现问题，时间间隔就太长了。&br&&br&&br&另外，请注意算法是“&b&逐渐增大TCP windows size&/b&”，&b&并不是&/b&“不停的计算/跟踪网络传输速度然后增加它”，后者是&b&不可行&/b&的。&br&&br&比如对被限速的高速网络来说，你是一个极短的周期传100个字节然后发现它能支持1Gbps对呢、还是连续测量几十个长周期、传一百万个字节后发现它被限速在1Mbps对？&br&如果网速很低，传100万个字节就要若干分钟呢？&br&&br&这种算法有办法实现吗？实现起来得有多复杂？能保证在复杂的网络状态下仍有可靠表现吗？&br&&br&很明显，这种想当然的算法看起来很合理，但根本就不是真实发生的过程，也不具丝毫可行性。&br&&br&&br&slow start会在如下三种情况出现时停止：&br&1、出现丢包&br&&blockquote&一个常识是，高速-低速链路交界处必然需要一个缓冲区；出现丢包就说明这个缓冲区已经被填满了、开始主动丢弃之后的数据包了。这是数据传输速率达到上限的一个标志。&/blockquote&&br&2、达到接收者TCP window size的限制&br&&blockquote&为了简化讨论，前面一直都没有区分发送者的CWND和接收者的RWND；事实上，真正决定链路速率上限的是RWND——很容易理解，你发再快，我接不了，你有什么办法？&br&&br&RWND可以由操作系统根据自身网络状况自动调优；也可以由应用根据自身情况指定——比如对http服务器来说，它的用户一般只接收信息、偶然会有少量上传信息；所以它的RWND经常指定为最大8K。这已经足够发送http请求或者发帖、贴图使用了。&br&&br&当发送者的CWND大小等于RWND时，slow start结束。&br&&br&&br&不仅如此。发送者可以发送多少信息，是依靠上一个ACK发来的、关于RWND还有多少空闲空间决定的。&br&假如接收者的应用死锁了，那么它就不会从RWND中把数据拿出去，RWND自然就一直保持满状态；那么当发送者发现ACK报告的、接收者的RWND没有空闲时，它就连一个多余的字节都不会发。&br&&br&&br&实际上的slow start过程就成了：逐渐增大CWND，直到它逼近RWND——CWND控制着实时数据发送速率，而RWND则控制了网速上限。&br&&br&这就使得slow start很少会把信息发送速率提高到远超链路允许上限的程度。&/blockquote&&br&3、达到slow start threshold&br&&blockquote&slow start threshold指出现丢包/超时时，min(CWND, RWND)大小的一半。&br&&br&它是拥塞控制算法和slow start算法的分界点：当CWND小于ssthresh时，切换slow start，大于ssthresh则切换到拥塞控制算法。&br&&br&这里要配合特定的拥塞控制算法才好深入讨论，就不多说了。&/blockquote&&br&&br&一旦出现如上三种情况之一，控制权就会切换到其它拥塞控制/避免算法上（&a href=&///?target=https%3A//en.wikipedia.org/wiki/TCP_congestion_control& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&TCP congestion control&i class=&icon-external&&&/i&&/a&）。&br&&br&标准的拥塞控制/避免算法有很多很多种，分别适应不同的网络情况，而且一直在增加中（比如说，适用于卫星网络的算法就和光纤网大不一样；之前还针对手机3G网络做过个偏底层的小东西，就和拥塞控制算法较过不少劲，幸好后来还是把它招安了）。&br&&br&这些算法可以更精确的使得传输速率逼近链路允许的上限，但增长速率较慢，每个RTT可能仅为TCP window size加1——特别的，当丢包出现时，某些拥塞控制算法会直接把CWND设置到当前CWND的一半，并不一定会利用slow start算法反复迭代。&br&&br&&br&总之，slow start一点都不“slow”。实际上，它是一个“疯狂”的、指数增加传输速率的算法；而且还会基于网络本身的特质，自动选择不同的起始速率和速率增长速度。
TCP拥塞控制算法造成的。这个机制叫做slow start。
简单说，当用户向服务器建立连接时，没人知道两者之间有效带宽能有多大——可能是1G的光纤，也可能是坑爹的2G手机网络…… 可采用的策略无非两种： 一是默认链路速…
CRLF 才是正统啊，当时的打印机用的就是 CRLF&br&在 ASCII 的设计里，CR 表示把打印头移动到行首，LF 表示把打印头向下移动一行，两者联用才是「换行」的效果（CR 在前是因为打印头移动到行首时间比较长，所以放在前面）。&br&Multics 使用驱动来隔离设备区别，于是就单用一个 LF 了。
CRLF 才是正统啊，当时的打印机用的就是 CRLF 在 ASCII 的设计里，CR 表示把打印头移动到行首，LF 表示把打印头向下移动一行，两者联用才是「换行」的效果（CR 在前是因为打印头移动到行首时间比较长，所以放在前面）。 Multics 使用驱动来隔离设备区别，于…
&p&这就是在作恶，开历史的倒车。&/p&&p&&br&&/p&&p&为何今次Apache会禁用呢？&/p&&p&完全源于这个条款：&/p&&blockquote&The license granted hereunder will terminate, automatically and without notice,
if you (or any of your subsidiaries, corporate affiliates or agents) initiate
directly or indirectly, or take a direct financial interest in, any Patent
Assertion: (i) against Facebook or any of its subsidiaries or corporate
affiliates, (ii) against any party if such Patent Assertion arises in whole or
in part from any software, technology, product or service of Facebook or any of
its subsidiaries or corporate affiliates, or (iii) against any party relating
to the Software. &/blockquote&&p&这么一大串，其实说白了就是只要你的用了它然后做出的东西牛逼到威胁到facebook了（不一定是实质威胁，只要facbook觉得是就行了，因为可以“indirectly”，这估计只有律师说得清）它就能直接给你取消授权，反告你一笔。&/p&&p&这根本就不是开源的精神。
&/p&&p&&b&开源的内在动力：&/b&&/p&&p&是什么让一群程序员无偿的给一个开源社区贡献代码？动力在哪里？&/p&&p&说起来你可能不信，其实开源社区是非常像真正实现了共产主义的地方。对于软件这个产品来说，设计复杂，但是生产简单，生产可以说是取之不尽用之不竭，所以开源我的代码给别人使用是一件非常简单的事情。对比传统产品，就算美国把f119的设计图纸开源给全世界，生产制造还是老大难问题，这就决定了高级的产品一定是稀缺的，这个稀缺性导致了共产主义的一大条件“物质极大丰富”是难以满足的。但是对于开源软件来说，世界级的软件可以轻轻松松人手一份，不存在任何稀缺性。满足了稀缺性以后，就可以按需分配，你的项目需要数据库，那你就从开源数据库里选，你不会想着需要数据库的时候还要霸占另一个前端库，因为没必要，取之不尽用之不竭，还会让人耻笑。按需分配完了以后激发的就是人们的创造力，我的需求给你提供的不是完全对的上，怎么办，改呗，加feature，更进一步，开源社区里有很多人是为了自我实现的目的来写代码的，为了实验新特性，为了改造旧世界，为了创造新活力。说白了，我给某个世界级的代码库贡献过代码是不是给人一种我写的代码也是世界级的错觉？所以这个吹牛逼的资本就是开源里面那么多程序员无偿为大公司劳动的原生动力，应该也是以后初步共产主义社会实现了以后社会运行的样子，没有酬劳，按需分配。这就成了一种良性循环，我们看看这个良性循环的点在哪里，在于程序员的原生动力，在于他们能简单优越的吹牛逼。这个就立足于这个世界级的软件，真的是有人在用，你这个牛逼吹出去，能真的给你带来经济利益，因为开源之外的世界还是资本主义社会，还是要挣钱才能糊口的。&/p&&p&&br&&/p&&p&&b&大公司开源的道理在哪里？&/b&&/p&&p&其一，互联网公司的核心竞争力在于数据，大公司公布一份同样的代码给你，你没有足够多的用户一样是形不成任何的竞争力的，开源反而还吸引了一群程序员为了吹水无偿给你改bug。其二，技术上开源可以吸引更多类似领域的程序员，招人更加有的放矢。其三，围绕某一个库可以建立一个生态环境，收集更多的脑洞反哺主库，俗话说三个臭皮匠赛过诸葛亮，就是这个道理，更别说这三个臭皮匠还是免费的。&/p&&p&&br&&/p&&p&&b&打破内在动力的后果：&/b&&/p&&p&这个的直接后果就是会导致react的生态恶化。前面说过了，开源有内在的原生动力的，这个条例导致大家都愿意承担因为使用react而产生的法律风险，而如果大家都不用你，谁还能说我给你react贡献代码是能吹牛逼的资本呢？我对别人说我给一个他根本不会用的库贡献过代码，跟我对别人说我对他一定会用的一个库贡献过代码，分量是完全不可比拟的。一个人精力有限，从这里吹不起牛逼自然就会流失到其他更有意义的地方吹牛逼，这个良性循环就会被打破。于是react就失去了开源带来的好处。&/p&&p&&br&&/p&&p&所以Facebook这个法条看上去对他有利，实则不然。Apache只是吹响了第一声号角罢了。可惜了，react。&/p&
这就是在作恶，开历史的倒车。 为何今次Apache会禁用呢？完全源于这个条款：The license granted hereunder will terminate, automatically and without notice,
if you (or any of your subsidiaries, corporate affiliates or agents) initiate
directly …
什么地位？&br&处于一个被低估的位置。之后影响力会越来越大，因为实在太强大了。&br&要不要学？&br&看你的需求，如果&br&&ol&&li&你要长期用Windows Server服务器&/li&&li&经常处理Office的一些重复性工作&br&&/li&&li&从事或学习Windows环境的网络安全&/li&&/ol&建议学习，PowerShell和.net平台，office的无缝结合非常强大，而且因为能bypass各种防护措施，之后肯定是Windows平台渗透神器。&br&&br&转载一段代码，获取当前最占内存的十个进程，并在Excel生成饼图&br&&div class=&highlight&&&pre&&code class=&language-powershell&&&span class=&c&&# create new excel instance&/span&
&span class=&nv&&$objExcel&/span& &span class=&p&&=&/span& &span class=&nb&&New-Object&/span& &span class=&n&&-comobject&/span& &span class=&n&&Excel&/span&&span class=&p&&.&/span&&span class=&n&&Application&/span&
&span class=&nv&&$objExcel&/span&&span class=&p&&.&/span&&span class=&n&&Visible&/span& &span class=&p&&=&/span& &span class=&nv&&$True&/span&
&span class=&nv&&$objWorkbook&/span& &span class=&p&&=&/span& &span class=&nv&&$objExcel&/span&&span class=&p&&.&/span&&span class=&n&&Workbooks&/span&&span class=&p&&.&/span&&span class=&n&&Add&/span&&span class=&p&&()&/span&
&span class=&nv&&$objWorksheet&/span& &span class=&p&&=&/span& &span class=&nv&&$objWorkbook&/span&&span class=&p&&.&/span&&span class=&n&&Worksheets&/span&&span class=&p&&.&/span&&span class=&n&&Item&/span&&span class=&p&&(&/span&&span class=&n&&1&/span&&span class=&p&&)&/span&
&span class=&c&&# write information to the excel file&/span&
&span class=&nv&&$i&/span& &span class=&p&&=&/span& &span class=&n&&0&/span&
&span class=&nv&&$first10&/span& &span class=&p&&=&/span& &span class=&p&&(&/span&&span class=&n&&ps&/span& &span class=&p&&|&/span& &span class=&n&&sort&/span& &span class=&n&&ws&/span& &span class=&n&&-Descending&/span& &span class=&p&&|&/span& &span class=&n&&select&/span& &span class=&n&&-first&/span& &span class=&n&&10&/span&&span class=&p&&)&/span&
&span class=&nv&&$first10&/span& &span class=&p&&|&/span& &span class=&k&&foreach&/span& &span class=&n&&-Process&/span& &span class=&p&