ck

ck手表是：Calvin Klein（简称：CK），中文名：卡尔文·克莱恩。Calvin Klein（简称：CK），是一个美国时装品牌，于1968年成立，创始者为同名设计师卡尔文·克雷恩，曾经连续四度获得知名的服装奖项；其创始人Calvin Klein 1942年出生于美国纽约，就读于著名的美国纽约时装学院（F I T）。CK手表注重本质，点点滴滴地展现出迷人之处。它们拥有瑞士制造商标的优点，并配以ETA机芯。Ck Calvin Klein手表因其独一无二的款式、流线型设计和无与伦比的价格，具有极大的吸引力。Ck手表系列产品有多种不同尺码、颜色和质料、反映了融合着朝气、青春和敢于冒险的现代生活风格。它们表现了现代图形设计与技术质量并重的特点，而这些特点都是瑞士制造商标所确保的。扩展资料：创始人：卡尔文·克雷恩（Calvin Klein）创始人Calvin Klein 1942年出生于美国纽约，就读于著名的美国纽约时装学院(F.I.T），1968年创办Calvin Klein“卡尔文·克雷恩”公司。Calvin Klein 是当之无愧为全美最具知名度的时装设计师。其产品范围除了高档次、高品位的经典之作外，克莱恩同时还是那些以青年人为消费对象的时髦的无性别香水和牛仔服装的倡导者。（Calvin Klein）有Calvin Klein（高级时装）、CK Calvin Klein（高级成衣）、Calvin Klein Jeans（牛仔）三大品牌，另外还经营休闲装、袜子、内衣、睡衣、泳衣、香水、眼镜、家饰用品等。参考资料：Calvin Klein百度百科

Calvin Klein（简称：CK），是一个美国时装品牌，于1968年成立，创始者为同名设计师卡尔文·克雷恩，曾经连续四度获得知名的服装奖项；其创始人Calvin Klein 1942年出生于美国纽约，就读于著名的美国纽约时装学院（F I T）。　　Calvin Klein是美国第一大设计师品牌；旗下的相关产品更是层出不穷，声势极为惊人。　　Calvin Klein一直坚守完美主义，每一件Calvin Klein时装都显得非常完美。因为体现了十足的纽约生活方式，Calvin Klein的服装成为了新一代职业妇女品牌选择中的最爱。　　Calvin Klein有“Calvin Klein Collection”（高级时装）、“CK Calvin Klein”（高级成衣）、“CKJ”（牛仔）三大品牌，另外还经营休闲装、袜子、内衣、睡衣、泳衣、香水、眼镜、家饰用品等。CK＆LN是一个待转让的品牌，服务项目: 服装；内衣；乳罩；婴儿全套衣；鞋（脚上的穿着物）；帽；袜；手套（服装）；领带；皮带（服饰用）；这个更像是一个CK的仿制品牌。

当想让一个容器做两件事情，或者使一个Docker镜像包含来自两个不同镜像的依赖库时，就需要知道每个镜像的Dockerfile。本文介绍了如何通过dockerhistory命令来对Docker镜像进行反向工程，得到它们的Dockerfile，并组织到一个Dockerfile里然后build，从而实现想做的事情。 常言道，“不要重复发明轮子！” 在使用Docker时，构建自己的镜像之前，最好在DockerHub寻找一些可以直接使用的镜像做练习。把软件架构分布到一系列容器中，每一个容器只做一件事情，这样的效果非常好。构建分布式应用的最好的基石是使用来自DockerHub的官方镜像，因为可以信任它们的质量。 在某些情况下，可能想让一个容器做两件不同的事情。而在另外一些情况下，可能想让一个Docker镜像包含来自两个不同镜像的依赖库。如果有每个镜像的Dockerfile，这是非常简单的。将它们组织到一个Dockerfile里然后build就行。 然而，大多数时间都在使用DockerHub上准备好的镜像，不会有它们的源Dockerfile。我花时间找一个可以合并（或flatten）两个不同Docker镜像的工具，当然没有它们的Dockerfile。也就是说在找一个能做下面这件事的东西： image1----->merged_image_12 / image2-- 此前在GitHub上有两个相关的讨论（1、2），尽管它们都被关闭了。 这可能吗？ 那么，是否存在工具能够像这样做吗：dockermergeimage2image2merged_image？ 没有！ 你甚至不可以用下面的方式来构建Dockerfile： FROMimage1 FROMimage2 简而言之，在一个Dockerfile里不能有多个基础镜像。 但是我需要这个功能！ 唯一的解决办法是取得这些镜像的Dockerfile，然后把它们组织到一个文件中，再进行构建。那么，我能在DockerHub上获得一个镜像的Dockerfile吗？幸运的是可以。它不能离线获取（译注：原文是online，但显然online时对于来自GitHub的自动构建镜像是可以直接获取的），但是你可以使用dockerhistory命令，通过反向工程获取。 怎么来使用？ 在你的机器上使用dockerpull从DockerHub下载镜像。 dockerpullimage1 dockerpullimage2 然后使用dockerhistory来取得构建这两个容器时运行的命令。 dockerhistory--no-trunc=trueimage>image1-dockerfile dockerhistory--no-trunc=trueimage2>image2-dockerfile 接下来打开这两个文件，你可以看到每个镜像的命令堆栈。这是因为Docker镜像通过层（阅读更多）的方式来构建。即你在Dockerfile中键入的每一个命令所构建的新镜像，都是在之前的命令产生的镜像之上。所以你可以对镜像进行逆向工程。 限制 不能对镜像进行反向工程的唯一场景，是镜像的维护者在他的Dockerfile中使用了ADD或COPY命令。你会看到这样一行： ADDfile:1ac56373f7983caf22 或ADDdir:cf6fe659e9d21535844 这是因为不知道维护者在他自己的机器上，包括镜像里使用了什么本地文件。

当想让一个容器做两件事情，或者使一个Docker镜像包含来自两个不同镜像的依赖库时，就需要知道每个镜像的Dockerfile。本文介绍了如何通过docker history命令来对Docker镜像进行反向工程，得到它们的Dockerfile，并组织到一个Dockerfile里然后build，从而实现想做的事情。常言道，“不要重复发明轮子！”在使用Docker时，构建自己的镜像之前，最好在Docker Hub寻找一些可以直接使用的镜像做练习。把软件架构分布到一系列容器中，每一个容器只做一件事情，这样的效果非常好。构建分布式应用的最好的基石是使用来自Docker Hub的官方镜像，因为可以信任它们的质量。在某些情况下，可能想让一个容器做两件不同的事情。而在另外一些情况下，可能想让一个Docker镜像包含来自两个不同镜像的依赖库。如果有每个镜像的Dockerfile，这是非常简单的。将它们组织到一个Dockerfile里然后build就行。然而，大多数时间都在使用Docker Hub上准备好的镜像，不会有它们的源Dockerfile。我花时间找一个可以合并（或flatten）两个不同Docker镜像的工具，当然没有它们的Dockerfile。也就是说在找一个能做下面这件事的东西：image 1 -- ---> merged_image_12 /image 2 --此前在GitHub上有两个相关的讨论（1、2），尽管它们都被关闭了。这可能吗？那么，是否存在工具能够像这样做吗：docker merge image2 image2 merged_image？没有！你甚至不可以用下面的方式来构建Dockerfile：FROM image1FROM image2简而言之，在一个Dockerfile里不能有多个基础镜像。但是我需要这个功能！唯一的解决办法是取得这些镜像的Dockerfile，然后把它们组织到一个文件中，再进行构建。那么，我能在Docker Hub上获得一个镜像的Dockerfile吗？ 幸运的是可以。它不能离线获取（译注：原文是online，但显然online时对于来自GitHub的自动构建镜像是可以直接获取的），但是你可以使用docker history命令，通过反向工程获取。怎么来使用？在你的机器上使用docker pull从Docker Hub下载镜像。docker pull image1docker pull image2然后使用docker history来取得构建这两个容器时运行的命令。docker history --no-trunc=true image > image1-dockerfiledocker history --no-trunc=true image2 > image2-dockerfile接下来打开这两个文件，你可以看到每个镜像的命令堆栈。这是因为Docker镜像通过层（阅读更多）的方式来构建。即你在Dockerfile中键入的每一个命令所构建的新镜像，都是在之前的命令产生的镜像之上。所以你可以对镜像进行逆向工程。限制不能对镜像进行反向工程的唯一场景，是镜像的维护者在他的Dockerfile中使用了ADD或COPY命令。你会看到这样一行：ADD file:1ac56373f7983caf22 或 ADD dir:cf6fe659e9d21535844 这是因为不知道维护者在他自己的机器上，包括镜像里使用了什么本地文件。

GitLab 是一个用于仓库管理系统的开源项目，使用Git作为代码管理工具，并在此基础上搭建起来的web服务。 GitLab由乌克兰程序员DmitriyZaporozhets和ValerySizov开发，它使用 Ruby语言 写成。后来，一部分用 Go语言 重写。截止2018年5月，该公司约有290名团队成员，以及2000多名开源贡献者。GitLab被IBM，Sony，JülichResearchCenter，NASA，Alibaba，Invincea，O"ReillyMedia，Leibniz-Rechenzentrum(LRZ)，CERN，SpaceX等组织使用。 Git、Github、Gitlab的区别： u2022 Git 一种代码版本管理系统，可以理解为标准或者统称。 u2022 Github 产品名称，基于git开发的代码管理系统，必须公开于互联网上的公共仓库，安全较低，私有项目需要另外付费。 u2022 Gitlab 产品名称，基于git开发的私有代码管理系统，开源免费、可自行管理的私有仓库，安全较高。 u2022 其它Git msysGit、 Gitee（码云）、Gitea、 Gogs、 GitBucket类似于Github、Gitlab 下面我们介绍如何用docker快速部署一套功能强大的gitlab-ce社区版代码仓库。 第一步、centos 7.6安装、配置IP、dns、网关等（略） 第二步、安装docker安装，参考作者前几天的文章《centos 7下安装docker》 https://www.toutiao.com/i6994343127452566054/ 第三步、安装docker-compose，参考作者前几天的文章《使用docker-compose运行docker容器》 https://www.toutiao.com/i6994600889604440608/ 第四步、下载gitlab-ce 13.12.10官方镜像 docker pull gitlab/gitlab-ce:13.12.10-ce.0 第五步、建立相关目录结构，配置目录权限 mkdir -p /data/gitlab/config mkdir -p /data/gitlab/data mkdir -p /data/gitlab/logs 第六步、建立docker-compose.yml cd /data/gitlab && vi docker-compose.yml docker-compose.yml具体配置和说明放本文章后面。 第七步、使用dc up -d起动容器 cd /data/gitlab && dc up -d 等待几分钟后服务初始化完成，使用宿主机IP在浏览器上进入gitlab，配置root管理员的密码。一套功能强大的gitlab代码仓库搭建完成，关于gitlab的具使用，后面会推出相关视频/文章说明。 附：docker-compose.yml version: "3.6" #配置编排的版本 services: gitlab: image: gitlab/gitlab-ce:13.12.10-ce.0 TZ: "Asia/Shanghai" #配置容器时区，不会有8小时差异 GITLAB_OMNIBUS_CONFIG: | external_url "http://172.18.95.158" #服务器访问地址，也可以是域名 gitlab_rails["time_zone"] = "Asia/Shanghai" #配置gitlab服务的时区 gitlab_rails["smtp_address"] = "smtp.exmail.qq.com" #管理员邮箱smtp地址 gitlab_rails["smtp_port"] = 465 #管理员邮箱服务器端口 gitlab_rails["smtp_user_name"] = "chenyk@xxxxxx.com" #管理员邮箱地址 gitlab_rails["smtp_password"] = "ZSfS11AssBXX" #管理员邮箱密码，配置后才可以给用户发邮件等信息 gitlab_rails["smtp_domain"] = "xxxxxx.com" #管理员邮箱域名 gitlab_rails["smtp_authentication"] = "login" #管理员邮箱的验证方式为login gitlab_rails["smtp_enable_starttls_auto"] = true #使用安全加密方式登陆管理员邮箱 gitlab_rails["smtp_tls"] = true gitlab_rails["gitlab_email_from"] = "chenyk@xxxxxx.com" #管理员邮箱账号 gitlab_rails["gitlab_shell_ssh_port"] = 22 ports: #放开gitlab 80端口，后面我们用80端口访问gitlab - "80:80" volumes: #挂载配置、数据持久化、日志目录 - ./config:/etc/gitlab - ./data:/var/opt/gitlab - ./logs:/var/log/gitlab

ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。 CAS：Compare and Swap，比较并交换。CAS有3个操作数：内存值V、预期值A、要修改的新值B。 当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则重新获取内存地址V的当前值，并重新计算想要修改的值（重新尝试的过程被称为自旋） 。修改变量的操作是一个原子操作，要么完成修改，要么完全没改；CAS被广泛的应用在Java的底层实现中。 在Java中，CAS主要是由sun.misc.Unsafe这个类通过JNI调用CPU底层指令实现 AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题。 AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus ReentrantLock的基本实现可以概括为： 先通过CAS尝试获取锁。如果此时已经有线程占据了锁，那就加入AQS队列并且被挂起。当锁被释放之后，排在CLH队列队首的线程会被唤醒，然后CAS再次尝试获取锁。 在这个时候，如果： 非公平锁 ：如果同时还有另一个线程进来尝试获取，那么有可能会让这个线程抢先获取； 公平锁 ：如果同时还有另一个线程进来尝试获取，当它发现自己不是在队首的话，就会排到队尾，由队首的线程获取到锁。

这个游戏怎么下载

野性攻击强度英文WOW术语表 Add - 一只额外的怪物加入到现有的战斗中。 AOE - Area Effect Damage，区域作用魔法。指的是一个可以伤害一个区域中的一群怪物的魔法，就像魔兽争霸三中的暴风雪魔法。 AE - Area Effect，区域作用伤害 AFK - Away from Keyboard，离开键盘。这意味着玩家离开了他的电脑。 Aggro - 这个词意味着怪物已经疯狂并且你已经将它们“激活”到开始攻击你的程度。它们现在开始会试图接近并攻击你。“鱼人被我Aggro了”或“如果你继续接近，鱼人将被Aggro”。 Aggro Radius - 怪物周围的区域，进入它意味着怪物会“苏醒”并攻击你。 Agi - Agility，敏捷 Avatar - 你的角色。 Buff - 施放于怪物或玩家身上的有益魔法。牧师的心火或撒满的嗜血术都是典型的Buff。 Carebear - 喜欢帮助其他玩家攻击怪物，而非在pvp中攻击其他玩家的玩家。 Caster - 非“坦克”型角色，如法师。 Cheese - 利用游戏的不平衡之处牟利。 Combat Pets - 被玩家控制的NPC，在战斗中帮助玩家及其队友。 CR - Corpse Retrevial，取回尸体 Creep - 怪物 Creep Jacking - 从魔兽争霸3引入的词语，当其他玩家与怪物战斗的时候趁机攻击该玩家。 Critters - 面对攻击不会反击的怪物，如小鹿和小兔子。 DD - Direct Damage，直接伤害。用来形容一个魔法所造成的伤害是一击生效而非持续产生伤害作用。 DMG - Damage，伤害。 DOT - Damage over time，在一段时间内不断对目标造成伤害。 DPS - Damage per second，每秒伤害。 De-Buff - 对一个单位施放一个具有负面效果的魔法使之战斗力降低。一个典型的“De-buff”就是减速。 FH - Full Health，生命值全满。 FM - Full Mana，法力全满。 Gank - PvP：当其他玩家与怪物战斗时趁机攻击该玩家。 GM - Game Master，游戏管理员。一些被暴雪娱乐雇佣以帮助、协助玩家的人。 Griefer - 试图骚扰或激怒其他玩家的人。 Grinding - 非常长时间呆在同一地点与同一类怪物战斗。 GS - Goldshire，闪金镇（地名）。 HP - Hit points/Health，伤害点数或生命值 IF - Ironforge，铁炉堡 Incoming (INC) - 意味着即将出现一次攻击。 Instancing - 在《魔兽世界》中有一类地下城，当你和你所在的队伍进入它的时候，你们会被载入到一个属于你们的这个地城的副本，只有你和你的队伍能够出现在这里，其他进入这一区域的队伍会自动进入他们自己的副本。 INT - Intelligence，智力。 Kiting - 玩家保持在敌人战斗范围以外的一种战术，从敌人身边跑开，同时对其造成伤害。 KOS - Killed on Sight，仇人见面。如果一名兽人走向一名人类守位，那么这名守位会在看的见它的情况下试图杀死他（激怒）。 KS - Kill Steal， 偷杀，试图杀死另一个人正在对付的怪物。 LFG - Looking for a group，寻找队伍以加入。 LFM - Looking for more，找寻更多的人组队。 LOL - Lots of Laugh/Laughing Out Loud，大笑。这个缩写意味着某些事的确十分好笑。但不幸的是，虽然这个词十分常用，但从很久以前开始它便容易引发一些不理智的行为（译者：毕竟有些人很容易被嘲笑激怒）。作为变通，你可以使用“呵呵呵呵”或“哈哈哈哈”来代替它，这两个词相对来说虽然不是最好的选择但更容易被接受。ROFL（笑到打滚）也是一个应该尽量避免使用的词。 LOM - Low on Mana，法力不足。 LOS - Line of Sight，视线。 LOOT - 从被杀死的怪物或宝箱里拿取财物。 LVL - Level，等级。 Mez - Mesmerize的缩写。意指例如催眠这类法术临时使目标丧失战斗能力。 MMO - Massively Multiplayer Online，大型多人在线。 MMOG - Massively Multiplayer Online Game，大型多人在线游戏。 MMORPG - Massive Multiplayer Online Role Playing Game，大型多玩家在线角色扮演游戏。 MOB - Mobile的缩写。指游戏中所有由电脑控制的角色。相类似的词有怪物等。 Nerf - 消弱。 Newbie - 菜鸟，有时用来形容新玩家的一个术语，但也用于指代那些技术不太好的玩家。 Newb - 新人的简称，见上。 Ninja - 没有经过其他玩家允许或趁别人没注意而拿走战利品。即没有经过允许拿走物品。 N00b - 一种用来称呼新人的不礼貌的说法。请不要使用。 NPC - Non-Player-Controlled Character，非玩家控制的角色。这种角色通常被服务器控制。也就是一名“电脑”角色。 OOM - Out of Mana，法力耗尽。人们通常用这句话提醒其他队员他已经没有法力不能再施放法术了，特别是治疗魔法。 PC - Player controlled character，玩家控制的角色。 Pet - 被玩家控制的非玩家生物，如一只狼或一只地狱犬等等。 PK - Player Kill或Player Killer，玩家在未经另一个玩家同意的情况下攻击并试图杀死他。 POP - Repopulation的缩写，指怪物刷新。 Proc - 激活。例如：一件具有特殊效果的武器将偶尔被“激活”。 PST - Please Send Tell，指说话的人想通过 /t(ell) 或 /w(hisper) 命令交流。 Puller - 负责吸引怪物的玩家。 Pulling - 队伍中的一名玩家负责吸引一只或几只怪物，并将他们带到队伍所在地，以便队伍中的其他玩家可以攻击这些怪物。这种方法可以避免一次被大群的怪物攻击。 PvE - Player vs. Environment， 玩家与电脑控制的对手之间的战斗。 PVP - Player vs. Player，玩家对玩家。也就是一名玩家攻击另一名玩家。 Raid - 由一群玩家在某一地区进行的大规模作战被称为Raid。 Res - Resurrect的缩写，复活。 Re-Spawn - 一只被杀死的怪物重新出生（被创建）。 Rest (state) - 人物劳累程度的指标，影响杀怪获得经验值的缩少。 Roll - 指你应该掷随机数字来决定物品的归属。 Root - 使用“定身”类法术困住目标，例如缠绕之根或催眠。 RR - Redridge Mountains，红脊山脉。 Small Pets - 跟随玩家的动物，不直接影响玩家或怪物，只是为了每矗乇鹗窍∩俚某栉铩 Spawns - 在游戏世界中，怪物被创建时所位于的地点或出现的过程。 SPI - Spirit，灵魂。 STA - Stamina，耐力。 Stack - 堆放在同一个格子中的同类物品的数量。 STR - Strength，力量。SW - Stormwind Tank - 能够承受很多伤害的近战角色，如一名战士。 Tap - 对怪物造成伤害，标为你的猎物。一旦你对怪物造成了伤害，只有你才能得到经验值和掠夺战利品。显示灰色名字的怪物表示已被链接到其他玩家，你不能获得经验值和战利品。 Taunt - 与Aggro相关。将怪物的注意力从其他玩家身上吸引到自己身上的能力。 Threat - 与Aggro相关。玩家产生或吸引了怪物的仇恨。 Train - 把一群怪物引向另一名玩家。这种行为通常不受欢迎。 Twink - 高等级带练低等级玩家，通常通过给与该等级通常无法获得的强力盔甲和武器。 UC - Undercity WF - Westfall，威斯特法（地名）。 Vendor Trash - 只有商人NPC才愿意购买的物品。 WoW - World of Warcraft WTB - Wanting to buy，想要购买。 WTS - Wanting to sell，想要出售。 XP or Exp - 经验值

// 服务器import java.io.*; import java.net.*; public class MyServer { public static void main(String[] args) throws IOException{ ServerSocket server=new ServerSocket(5678); while (true) { Socket client=server.accept(); BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream())); PrintWriter out=new PrintWriter(client.getOutputStream()); while(true){ String str=in.readLine(); System.out.println(str); out.println("has receive...."); out.flush(); if(str.equals("exit")) break; } client.close(); } } } // 客户端import java.net.*; import java.io.*; public class Client{ static Socket server; public static void main(String[] args)throws Exception{ server=new Socket(InetAddress.getLocalHost(),5678); BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); PrintWriter out=new PrintWriter(server.getOutputStream()); BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); while(true){ String str=wt.readLine(); out.println(str); out.flush(); if(str.equals("end")){ break; } System.out.println(in.readLine()); } server.close(); } }

已知某一局域网中若干台机器上的根目录下都存在同一个xml文件//看上去好像是说这些机器都是web服务器如果是这样的话，可以：使用.net 的WebRequest类进行遍历这些服务器,然后读取这个xml文件。另：可以直接使用xmldocument对象进行读取

out.println("test_outputs");后面加个out.flush();

从函数调用上来分析（msdn)：一旦完成了套接字的连接，应当将套接字关闭，并且释放其套接字句柄所占用的所有资源。真正释放一个已经打开的套接字句柄的资源直接调用closesocket即可，但要明白closesocket的调用可能会带来负面影响，具体的影响和如何调用有关，最明显的影响是数据丢失，因此一般都要在closesocket之前调用shutdown来关闭套接字。 shutdown:为了保证通信双方都能够收到应用程序发出的所有数据，一个合格的应用程序的做法是通知接受双发都不在发送数据！这就是所谓的“正常关闭 ”套接字的方法，而这个方法就是由shutdown函数,传递给它的参数有SD_RECEIVE,SD_SEND,SD_BOTH三种，如果是 SD_RECEIVE就表示不允许再对此套接字调用接受函数。这对于协议层没有影响，另外对于tcp套接字来说，无论数据是在等候接受还是即将抵达，都要重置连接（注意对于udp协议来说，仍然接受并排列传入的数据，因此udp套接字而言shutdown毫无意义）。如果选择SE_SEND,则表示不允许再调用发送函数。对于tcp套接字来说，这意味着会在所有数据发送出并得到接受端确认后产生一个FIN包。如果指定SD_BOTH，答案不言而喻。 closesocket:对此函数的调用会释放套接字的描述，这个道理众所周知（凡是经常翻阅msdn的程序员），因此，调用此函数后，再是用此套接字就会发生调用失败，通常返回的错误是WSAENOTSOCK。此时与被closesocket的套接字描述符相关联的资源都会被释放，包括丢弃传输队列中的数据！！！！对于当前进程中的线程来讲，所有被关起的操作，或者是被挂起的重叠操作以及与其关联的任何事件，完成例程或完成端口的执行都将调用失败！另外 SO_LINGER标志还影响着closesocket的行为，但对于传统的socket程序，这里不加解释 因此可以可以看出shutdown对切断连接有着合理的完整性。 下面从tcp协议上来分析shutdown和closesocket的行为（behavior)：closesocket或shutdown(使用 SD_SEND当作参数时）,会向通信对方发出一个fin包，而此时套接字的状态会由ESTABLISHED变成FIN_WAIT_1，然后对方发送一个 ACK包作为回应，套接字又变成FIN_WAIT_2，如果对方也关闭了连接则对方会发出FIN，我方会回应一个ACK并将套接字置为 TIME_WAIT。因此可以看出closesocket,shutdown所进行的TCP行为是一样的，所不同的是函数部分，shutdown会确保 windows建立的数据传输队列中的数据不被丢失，而closesocket会冒然的抛弃所有的数据，因此如果你愿意closesocket完全可以取代shutdown,然而在数据交互十分复杂的网络协议程序中，最好还是shutdown稳妥一些！？有关TCP协议的连接原理清访问 http://www.rfc-editor.org第RFC793号文件

参考一般的JAVA的socket编程，如果通过手机网络，就不要使用UDP即可。

import java.awt.*;import java.awt.event.*;import java.io.*;import java.net.*;public class ChatClient extends Frame {Socket s = null;DataOutputStream dos = null;DataInputStream dis = null;private boolean bConnected = false;TextField tfTxt = new TextField();TextArea taContent = new TextArea();Thread tRecv = new Thread(new RecvThread()); public static void main(String[] args) {new ChatClient().launchFrame(); }public void launchFrame() {setLocation(400, 300);this.setSize(300, 300);add(tfTxt, BorderLayout.SOUTH);add(taContent, BorderLayout.NORTH);pack();this.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent arg0) {disconnect();System.exit(0);}});tfTxt.addActionListener(new TFListener());setVisible(true);connect();tRecv.start();}public void connect() {try {s = new Socket("127.0.0.1", 8888);dos = new DataOutputStream(s.getOutputStream());dis = new DataInputStream(s.getInputStream());System.out.println("connected!");bConnected = true;} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}public void disconnect() {try {dos.close();dis.close();s.close();} catch (IOException e) {e.printStackTrace();}/*try {bConnected = false;tRecv.join();} catch(InterruptedException e) {e.printStackTrace();} finally {try {dos.close();dis.close();s.close();} catch (IOException e) {e.printStackTrace();}}*/}private class TFListener implements ActionListener {public void actionPerformed(ActionEvent e) {String str = tfTxt.getText().trim();//taContent.setText(str);tfTxt.setText("");try {//System.out.println(s);dos.writeUTF(str);dos.flush();//dos.close();} catch (IOException e1) {e1.printStackTrace();}}}private class RecvThread implements Runnable {public void run() {try {while(bConnected) {String str = dis.readUTF();//System.out.println(str);taContent.setText(taContent.getText() + str + " ");}} catch (SocketException e) {System.out.println("退出了，bye!");} catch (EOFException e) {System.out.println("推出了，bye - bye!");} catch (IOException e) {e.printStackTrace();} }}}import java.io.*;import java.net.*;import java.util.*;public class ChatServer {boolean started = false;ServerSocket ss = null;List<Client> clients = new ArrayList<Client>();public static void main(String[] args) {new ChatServer().start();}public void start() {try {ss = new ServerSocket(8888);started = true;} catch (BindException e) {System.out.println("端口使用中....");System.out.println("请关掉相关程序并重新运行服务器！");System.exit(0);} catch (IOException e) {e.printStackTrace();}try {while(started) {Socket s = ss.accept();Client c = new Client(s);System.out.println("a client connected!");new Thread(c).start();clients.add(c);//dis.close();}} catch (IOException e) {e.printStackTrace();} finally {try {ss.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}class Client implements Runnable {private Socket s;private DataInputStream dis = null;private DataOutputStream dos = null;private boolean bConnected = false;public Client(Socket s) {this.s = s;try {dis = new DataInputStream(s.getInputStream());dos = new DataOutputStream(s.getOutputStream());bConnected = true;} catch (IOException e) {e.printStackTrace();}}public void send(String str) {try {dos.writeUTF(str);} catch (IOException e) {clients.remove(this);System.out.println("对方退出了！我从List里面去掉了！");//e.printStackTrace();}}public void run() {try {while(bConnected) {String str = dis.readUTF();System.out.println(str);for(int i=0; i<clients.size(); i++) {Client c = clients.get(i);c.send(str);//System.out.println(" a string send !");}/*for(Iterator<Client> it = clients.iterator(); it.hasNext(); ) {Client c = it.next();c.send(str);}*//*Iterator<Client> it = clients.iterator();while(it.hasNext()) {Client c = it.next();c.send(str);}*/}} catch (EOFException e) {System.out.println("Client closed!");} catch (IOException e) {e.printStackTrace();} finally {try {if(dis != null) dis.close();if(dos != null) dos.close();if(s != null) {s.close();//s = null;}} catch (IOException e1) {e1.printStackTrace();}}}}}

首先，可以在客户端和服务器端协商一个传输协议，在这个传输协议中可以在数据包头增加一个字段，该字段描述后面数据的具体长度，这样在接收方就可以根据这个字段知道要分配多长的空间和什么时候结束。然后，网络传输的字节序都是确定的，都是大端序(Big-Endian)，因此不需要考虑大小端问题

实现方法 以及API 不同。运用的地方不同。当然主要取决去二者的各自特点。1)TCP是面向连接的传输控制协议，而UDP提供了无连接的数据报服务；（2）TCP具有高可靠性，确保传输数据的正确性，不出现丢失或乱序；UDP在传输数据前不建立连接，不对数据报进行检查与修改，无须等待对方的应答，所以会出现分组丢失、重复、乱序，应用程序需要负责传输可靠性方面的所有工作；（3）也正因为以上特征，UDP具有较好的实时性，工作效率较TCP协议高；（4）UDP段结构比TCP的段结构简单，因此网络开销也小。具体二种协议没有好坏，只有适合，有时候二者结合，比如QQ就是两种协议都有，比如组播通信的时候只能用udp

引入线程的目的是为了监听端口，如果只用一个单线程，当监听一个端口的时候 ，就不能响应其他事件，所以要用多线程来执行应用程序

//获取时间CString strTime;CTime st = CTime::GetCurrentTime();strTime = st.Format("%Y%m%d%H%M%S");//创建服务器端 WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 1, 1 ); err = WSAStartup( wVersionRequested, &wsaData ); if ( err != 0 ) { return; } if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( ); return; } SOCKET sock = socket(AF_INET,SOCK_STREAM,0); int opt = 1; int len11 = sizeof(opt); setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char*)&opt,len11); if (sock == INVALID_SOCKET) { // "初始化失败" ; closesocket(sock); return; } SOCKADDR_IN addrsrv; addrsrv.sin_family = AF_INET; addrsrv.sin_port = htons(6001); addrsrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY); if (bind(sock,(SOCKADDR*)&addrsrv,sizeof(SOCKADDR)) == SOCKET_ERROR) { // "绑定失败" closesocket(sock); return; } listen(sock,10);//客户端接收服务器连接char m_recvBuf[2000];memset(m_recvBuf, 0, 2000);while(TRUE){ SOCKET sNew = ::accept(sock, (SOCKADDR*)&addrRemote, &nAddrLen);//接收到客户端连接//发送时间 int hvsndlen = 0; int sndlen = 0; while ((len -hvsndlen) > 0) { sndlen = send(soc,(LPCTSTR)strTime +hvsndlen,len-hvsndlen,0); if (sndlen == SOCKET_ERROR) { return -1; } hvsndlen += sndlen; }}//把以上程序放入你的主程序中，应该可以运行。里面有CString类型，如果用不习惯，你可以把CTime 转换成其他类型

很高兴协助你完成朋友

bind函数的原型是int bind(SOCKET s, const sockaddr *addr, int namelen);第二个参数的类型是const sockaddr*，而不是sockaddr_in*。你传递的参数类型错误。

对于通信来说，不存在绝对的服务器和客户端，谁在等待别人来，谁就是服务器，谁主动去联系人，谁就是客户端。所以。你要想客户端接受消息，那在启动客户端的时候，在客户端程序里开始一个提供端口的Socket就可以了。ServerSocket serverSocket = new ServerSocket(5000);while (true) {final Socket socket = serverSocket.accept();new Thread() {Socket mySocket = socket;@Overridepublic void run() {try {System.out.println(mySocket);InputStream is = mySocket.getInputStream();byte[] bytes = new byte[1024];int n = is.read(bytes);System.out.println(new String(bytes, 0, n));OutputStream os = mySocket.getOutputStream();os.write(("server reply at time " + new Date().toString()).getBytes());mySocket.close();} catch (Exception e) {e.printStackTrace();}}}.start();}

无

你说的效果无法实现。

更新完数据后调用下UpdateWindow();

主要是你通过socket api封装要发送的数据，内部会自动封装成数据流进行传输。1，什么是Socket网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。2，Socket通讯的过程Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：（1） 创建Socket；（2） 打开连接到Socket的输入/出流；（3） 按照一定的协议对Socket进行读/写操作；（4） 关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）3，创建Socket创建Socketjava在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：Socket(InetAddress address, int port);Socket(InetAddress address, int port, boolean stream);Socket(String host, int prot);Socket(String host, int prot, boolean stream);Socket(SocketImpl impl)Socket(String host, int port, InetAddress localAddr, int localPort)Socket(InetAddress address, int port, InetAddress localAddr, int localPort)ServerSocket(int port);ServerSocket(int port, int backlog);ServerSocket(int port, int backlog, InetAddress bindAddr)Socket client = new Socket("127.0.01.", 80);ServerSocket server = new ServerSocket(80);在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

你用异步socket接收的时候确实会出现这个情况而且是正常的。你可以自己在发送的数据前面加上一个数据头，比如一个结构体说明一下数据的长度之类的信息

Socket是套接字，跟IP绑定后，可以进行网络通信

//服务端server.c#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <sys/types.h>#include <netinet/in.h>#include <sys/socket.h>#include <sys/wait.h>#define SERVPORT 6000 /*服务器监听端口号 */#define BACKLOG 10 /* 最大同时连接请求数 */#define MAXDATASIZE 100main(){ char buf[MAXDATASIZE]; int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */ struct sockaddr_in my_addr; /* 本机地址信息 */ struct sockaddr_in remote_addr; /* 客户端地址信息 */ if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket创建出错！"); exit(1); } my_addr.sin_family=AF_INET; my_addr.sin_port=htons(SERVPORT); my_addr.sin_addr.s_addr = INADDR_ANY; bzero(&(my_addr.sin_zero),8); if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) { perror("bind出错！"); exit(1); } if (listen(sockfd, BACKLOG) == -1) { perror("listen出错！"); exit(1); } while(1) { sin_size = sizeof(struct sockaddr_in); if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1) { perror("accept出错"); continue; } printf("received a connection from %s ", inet_ntoa(remote_addr.sin_addr)); if (!fork()) { /* 子进程代码段 */ if ((recvbytes=recv(client_fd, buf, MAXDATASIZE, 0)) ==-1) { perror("recv出错！"); close(client_fd); exit(0); } buf[recvbytes] = ""; printf("from client Received: %s",buf); if (send(client_fd, "thanks! ", 8, 0) == -1) perror("send出错！"); close(client_fd); exit(0); } close(client_fd); }}//客户端client.c#include<stdio.h>#include <stdlib.h>#include <errno.h>#include <string.h>#include <netdb.h>#include <sys/types.h>#include <netinet/in.h>#include <sys/socket.h>#define SERVPORT 6000#define MAXDATASIZE 100main(int argc, char *argv[]){ int sockfd, recvbytes; char buf[MAXDATASIZE]; struct hostent *host; struct sockaddr_in serv_addr; if (argc < 2) { fprintf(stderr,"Please enter the server"s hostname! "); exit(1); } if((host=gethostbyname(argv[1]))==NULL) { herror("gethostbyname出错！"); exit(1); } if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket创建出错！"); exit(1); } serv_addr.sin_family=AF_INET; serv_addr.sin_port=htons(SERVPORT); serv_addr.sin_addr = *((struct in_addr *)host->h_addr); bzero(&(serv_addr.sin_zero),8); if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1) { perror("connect出错！"); exit(1); }if (send(sockfd, "hello! ", 7, 0) == -1) { perror("send出错！"); exit(1); } if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) { perror("recv出错！"); exit(1); } buf[recvbytes] = ""; printf("Received: %s",buf); close(sockfd);}

顶我，我告诉你！gongtaikj@163.com

wVersionRequested = MAKEWORD( 1, 1 ); //将两个byte型合并成一个word型，一个在高8位(b)，一个在低8位(a) err = WSAStartup( wVersionRequested, &wsaData ); if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( ); return; } //查找是否有可用的WinSock DLL/*****************上面的都是windows操作系统下的初始化工作******************************/SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0); //创建套接字addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//设置服务器地址，INADDR_ANY表示任意地址，一般只有一个网卡，就是你本机上使用的那个地址addrSrv.sin_family=AF_INET; //地址协议族addrSrv.sin_port=htons(6000); //设置端口，htons()中h表示host,n表示net，本地字节要转换成网络字节，即host to net ，s表示shortbind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));// 绑定端口listen(sockSrv,5); //监听创建的套接字，最大连接数5

实现方法 以及API 不同。运用的地方不同。当然主要取决去二者的各自特点。1)TCP是面向连接的传输控制协议，而UDP提供了无连接的数据报服务；（2）TCP具有高可靠性，确保传输数据的正确性，不出现丢失或乱序；UDP在传输数据前不建立连接，不对数据报进行检查与修改，无须等待对方的应答，所以会出现分组丢失、重复、乱序，应用程序需要负责传输可靠性方面的所有工作；（3）也正因为以上特征，UDP具有较好的实时性，工作效率较TCP协议高；（4）UDP段结构比TCP的段结构简单，因此网络开销也小。具体二种协议没有好坏，只有适合，有时候二者结合，比如QQ就是两种协议都有，比如组播通信的时候只能用udp

下面是代码， socket就是绑定IP和端口后，并双方相互连接后，一般就是客户端 和服务器，利用sendto recvfrom 函数发送接收，这个流是字节数据，下面是udp发送接收数据的例子，可以看看，前面大部分代码都是初始化网络，绑定IP和端口 socket的初始化功能的，核心在sendto 和recvfrom //发送端程序#include <stdio.h>#include <winsock.h>int main(int argc, char* argv[]){ WSADATA wsaData; //指向WinSocket信息结构的指针 SOCKET sockListener; SOCKADDR_IN sin,saUdpServ; BOOL fBroadcast = TRUE; char sendBuff[1024]; int nSize; int ncount=0; if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化 { printf("Can"t initiates windows socket!Program stop. ");//初始化失败返回-1 return -1; } sockListener=socket(PF_INET,SOCK_DGRAM,0); setsockopt ( sockListener,SOL_SOCKET,SO_BROADCAST,(CHAR *)&fBroadcast,sizeof ( BOOL )); sin.sin_family = AF_INET; sin.sin_port = htons(0); sin.sin_addr.s_addr = htonl(INADDR_ANY); if(bind( sockListener, (SOCKADDR *)&sin, sizeof(sin))!=0) { printf("Can"t bind socket to local port!Program stop. ");//初始化失败返回-1 return -1; } saUdpServ.sin_family = AF_INET; saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST ); saUdpServ.sin_port = htons (7001);//发送用的端口，可以根据需要更改 nSize = sizeof ( SOCKADDR_IN ); while(1) { sprintf(sendBuff,"Message %d",ncount++); sendto ( sockListener,sendBuff, lstrlen (sendBuff), 0, (SOCKADDR *) &saUdpServ, sizeof ( SOCKADDR_IN )); printf("%s ",sendBuff); }return 0;}///////////////////////接收#include <stdio.h>#include <winsock.h>#include <conio.h>int main(int argc, char* argv[]){ WSADATA wsaData; //指向WinSocket信息结构的指针 SOCKET sockListener; SOCKADDR_IN sin,saClient; char cRecvBuff[1024]; int nSize,nbSize; int iAddrLen=sizeof(saClient); if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化 { printf("Can"t initiates windows socket!Program stop. ");//初始化失败返回-1 return -1; } sockListener=socket(AF_INET, SOCK_DGRAM,0); sin.sin_family = AF_INET; sin.sin_port = htons(7001);//发送端使用的发送端口，可以根据需要更改 sin.sin_addr.s_addr = htonl(INADDR_ANY); if(bind( sockListener, (SOCKADDR FAR *)&sin, sizeof(sin))!=0) { printf("Can"t bind socket to local port!Program stop. ");//初始化失败返回-1 return -1; } while(1) { nSize = sizeof ( SOCKADDR_IN ); if((nbSize=recvfrom (sockListener,cRecvBuff,1024,0,(SOCKADDR FAR *) &saClient,&nSize))==SOCKET_ERROR) { printf("Recive Error"); break; } cRecvBuff[nbSize] = ""; printf("%s ",cRecvBuff);} return 0;}

？？？？这个实在是？？？？封装？？？TCP/IP中要TCP包到IP包到以太帧的顺序封装数据包，你要传输的数据可能在不同的包中，每个包都有不同的数据头。

我写了一个, 因为是刚学 ,只能实现两个人聊天 ,程序很简单 只有100多行

使用 vc 吧。是不是纯很重要吗？？？？？？

150分，给力个屁啊。整理一份这个都不止150块。

SOCKET在原理上应该是一样的，只是不同系统的运行机置有些不同。Socket 编程 windows到Linux代码移植遇到的问题1、一些常用函数的移植 2、网络socket相关程序从windows移植到linux下需要注意的 1)头文件 windows下winsock.h/winsock2.hlinux下sys/socket.h错误处理：errno.h 其他常用函数的头文件可到命令行下用man指令查询。2)初始化windows下需要用WSAStartuplinux下不需要（很方便），直接可以使用3)关闭socketwindows下closesocket(...)linux下close(...)4)类型windows下SOCKET在linux下为int类型5)绑定地址的结构体名称相同，都是struct sockaddr、struct sockaddr_in，这两者通常转换使用；

查看java的API文档或者看socket的源码

1)头文件windows下winsock.h/winsock2.hlinux下sys/socket.h错误处理：errno.h其他常用函数的头文件可到命令行下用man指令查询。2)初始化windows下需要用WSAStartuplinux下不需要（很方便），直接可以使用3)关闭socketwindows下closeso

有问题请找锐英源啊。结合工作经验、开源、英语、视频教学、在线教学、阶段式兴趣和实践。面授小班授课，加强记忆，从头到尾结合实践。网校是视频教学和在线交流结合的。视频通俗易懂逐渐深入，在线灵活生动结合具体代码，可以结合例子，远程协助进行指导。

　　下面大概分几个方面进行罗列：　　Linux要包含　　[cpp]　　#include<sys/socket.h>　　#include<netinet/in.h>　　#include<netdb.h>　　#include<arpa/inet.h>　　等头文件，而windows下则是包含　　[cpp]　　#include<winsock.h>　　。　　Linux中socket为整形，Windows中为一个SOCKET。　　Linux中关闭socket为close，Windows中为closesocket。　　Linux中有变量socklen_t，Windows中直接为int。　　因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。　　设置socet选项，比如设置socket为非阻塞的。Linux下为　　[cpp]　　flag=fcntl(fd,F_GETFL);　　fcntl(fd,F_SETFL,flag|O_NONBLOCK);　　，Windows下为　　[cpp]　　flag=1;　　ioctlsocket(fd,FIONBIO,(unsignedlong*)&flag);　　。　　当非阻塞socket的TCP连接正在进行时，Linux的错误号为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。

socket相关程序从windows移植到linux下需要注意的 1)头文件windows下winsock.h/winsock2.hlinux下sys/socket.h错误处理：errno.h 其他常用函数的头文件可到命令行下用man指令查询。2)初始化windows下需要用WSAStartuplinux下不需要（很方便），直接可以使用3)关闭socketwindows下closesocket(...)linux下close(...)4)类型windows下SOCKET在linux下为int类型5)绑定地址的结构体名称相同，都是struct sockaddr、struct sockaddr_in，这两者通常转换使用；在Windows下面名称都是大写，而在Linux下为小写常用：Linux下：sockaddr_in destAddr;destAdd.sin_family=AF_INET;destAddr.sin_port=htons(2030);destAddr.sin_addr.s_addr=inet_addr("192.168.1.1");Windows下：SOCKADDR_IN destAddr;destAddr.sin_addr.S_un.S_addr=inet_addr("192.168.1.1");但结构体中成员的名称不同Windows中结构体成员struct sockaddr_in { short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8];};struct sockaddr { u_short sa_family; char sa_data[14];}; struct in_addr { union { struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b; struct { u_short s_w1,s_w2; } S_un_w; u_long S_addr; } S_un;};下面的一些宏可以使windows下的程序移植到linux下（通过类型的重新定义，使代码具有linux和windows下的移植性）[cpp] view plaincopy #ifdef WIN32 typedef int socklen_t; typedef int ssize_t; #endif #ifdef __LINUX__ typedef int SOCKET; typedef unsigned char BYTE; typedef unsigned long DWORD; #define FALSE 0 #define SOCKET_ERROR (-1) #endif [cpp] view plain copy #ifdef WIN32 typedef int socklen_t; typedef int ssize_t; #endif #ifdef __LINUX__ typedef int SOCKET; typedef unsigned char BYTE; typedef unsigned long DWORD; #define FALSE 0 #define SOCKET_ERROR (-1) #endif 6)获取错误码windows下getlasterror()/WSAGetLastError()linux下errno变量7)设置非阻塞windows下ioctlsocket()linux下fcntl() <fcntl.h>8)send函数最后一个参数windows下一般设置为0linux下最好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可 能会导致程序退出。9)毫秒级时间获取windows下GetTickCount()linux下gettimeofday()10)数据类型的一些转化通用的：小端到大端（网络协议使用）的转换：htonl, htons点分十进制IP和整数之间的相互转换：inet_addr()（该函数将点分十进制转为整数），inet_aton()，inet_ntoa()，inet_pton()（linux下独有 该函数可以实现相互之间的转换）使用到的头文件不相同，linux下用man命令查询。另外注意：linux下使用的套接字为伯克利套接字，因此在select()函数的使用上（第一个参数的设置）也有区别；windows下为了与伯克利套接字匹配，第一个参数是无所谓，一般可设为0；int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！3、多线程多线程: (win)process.h --〉(linux)pthread.h_beginthread --> pthread_create_endthread --> pthread_exit

基于C#的socket编程的TCP异步实现一、摘要　　本篇博文阐述基于TCP通信协议的异步实现。二、实验平台　　VisualStudio2010三、异步通信实现原理及常用方法3.1建立连接　　　在同步模式中，在服务器上使用Accept方法接入连接请求，而在客户端则使用Connect方法来连接服务器。相对地，在异步模式下，服务器可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务，在客户端则通过BeginConnect方法和EndConnect方法来实现与服务器的连接。　　BeginAccept在异步方式下传入的连接尝试，它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前，必须使用Listen方法来侦听是否有连接请求，BeginAccept的函数原型为：BeginAccept(AsyncCallbackAsyncCallback,Ojbectstate)参数：AsyncCallBack：代表回调函数state：表示状态信息，必须保证state中包含socket的句柄　　使用BeginAccept的基本流程是：(1)创建本地终节点，并新建套接字与本地终节点进行绑定；(2)在端口上侦听是否有新的连接请求；(3)请求开始接入新的连接，传入Socket的实例或者StateOjbect的实例。　　参考代码：复制代码//定义IP地址IPAddresslocal=IPAddress.Parse("127.0,0,1");IPEndPointiep=newIPEndPoint(local,13000);//创建服务器的socket对象Socketserver=newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);server.Bind(iep);server.Listen(20);server.BeginAccecpt(newAsyncCallback(Accept),server);复制代码　　当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，而该回调函数必须包括用来结束接入连接操作的EndAccept()方法。该方法参数列表为SocketEndAccept(IAsyncResultiar)下面为回调函数的实例：复制代码voidAccept(IAsyncResultiar){//还原传入的原始套接字SocketMyServer=(Socket)iar.AsyncState;//在原始套接字上调用EndAccept方法，返回新的套接字Socketservice=MyServer.EndAccept(iar);}复制代码　　至此，服务器端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数，以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用：Socketsocket=newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)IPAddressip=IPAddress.Parse("127.0.0.1");IPEndPointiep=newIPEndPoint(ip,13000);socket.BeginConnect(iep,newAsyncCallback(Connect),socket);　　EndConnect是一种阻塞方法，用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示：复制代码voidConnect(IAsyncResultiar){Socketclient=(Socket)iar.AsyncState;try{client.EndConnect(iar);}catch(Exceptione){Console.WriteLine(e.ToString());}finally{}}复制代码　　除了采用上述方法建立连接之后，也可以采用TcpListener类里面的方法进行连接建立。下面是服务器端对关于TcpListener类使用BeginAccetpTcpClient方法处理一个传入的连接尝试。以下是使用BeginAccetpTcpClient方法和EndAccetpTcpClient方法的代码：复制代码publicstaticvoidDoBeginAccept(TcpListenerlistner){//开始从客户端监听连接Console.WriteLine("Waittingforaconnection");//接收连接//开始准备接入新的连接，一旦有新连接尝试则调用回调函数DoAcceptTcpClietlistner.BeginAcceptTcpClient(newAsyncCallback(DoAcceptTcpCliet),listner);}//处理客户端的连接publicstaticvoidDoAcceptTcpCliet(IAsyncResultiar){//还原原始的TcpListner对象TcpListenerlistener=(TcpListener)iar.AsyncState;//完成连接的动作，并返回新的TcpClientTcpClientclient=listener.EndAcceptTcpClient(iar);Console.WriteLine("连接成功");}复制代码　　代码的处理逻辑为：(1)调用BeginAccetpTcpClient方法开开始连接新的连接，当连接视图发生时，回调函数被调用以完成连接操作；(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcpClient传入的listner实例；(3)在得到listener对象后，用它调用EndAcceptTcpClient方法，该方法返回新的包含客户端信息的TcpClient。　　BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接，这里和第一种方法并无区别。下面看实例：复制代码publicvoiddoBeginConnect(IAsyncResultiar){Socketclient=(Socket)iar.AsyncState;//开始与远程主机进行连接client.BeginConnect(serverIP[0],13000,requestCallBack,client);Console.WriteLine("开始与服务器进行连接");}privatevoidrequestCallBack(IAsyncResultiar){try{//还原原始的TcpClient对象TcpClientclient=(TcpClient)iar.AsyncState;//client.EndConnect(iar);Console.WriteLine("与服务器{0}连接成功",client.Client.RemoteEndPoint);}catch(Exceptione){Console.WriteLine(e.ToString());}finally{}}复制代码　　以上是建立连接的两种方法。可根据需要选择使用。3.2发送与接受数据　　在建立了套接字的连接后，就可以服务器端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接，否则会出异常。下面演示代码：复制代码privatestaticvoidSend(Sockethandler,Stringdata){//ConvertthestringdatatobytedatausingASCIIencoding.byte[]byteData=Encoding.ASCII.GetBytes(data);//Beginsendingthedatatotheremotedevice.handler.BeginSend(byteData,0,byteData.Length,0,newAsyncCallback(SendCallback),handler);}privatestaticvoidSendCallback(IAsyncResultar){try{//Retrievethesocketfromthestateobject.Sockethandler=(Socket)ar.AsyncState;//Completesendingthedatatotheremotedevice.intbytesSent=handler.EndSend(ar);Console.WriteLine("Sent{0}bytestoclient.",bytesSent);handler.Shutdown(SocketShutdown.Both);handler.Close();}catch(Exceptione){Console.WriteLine(e.ToString());}}复制代码　　接收数据是通过BeginReceive和EndReceive方法：复制代码privatestaticvoidReceive(Socketclient){try{//Createthestateobject.StateObjectstate=newStateObject();state.workSocket=client;//Beginreceivingthedatafromtheremotedevice.client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,newAsyncCallback(ReceiveCallback),state);}catch(Exceptione){Console.WriteLine(e.ToString());}}privatestaticvoidReceiveCallback(IAsyncResultar){try{//Retrievethestateobjectandtheclientsocket//fromtheasynchronousstateobject.StateObjectstate=(StateObject)ar.AsyncState;Socketclient=state.workSocket;//Readdatafromtheremotedevice.intbytesRead=client.EndReceive(ar);if(bytesRead>0){//Theremightbemoredata,sostorethedatareceivedsofar.state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));//Gettherestofthedata.client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,newAsyncCallback(ReceiveCallback),state);}else{//Allthedatahasarrived;putitinresponse.if(state.sb.Length>1){response=state.sb.ToString();}//Signalthatallbyteshavebeenreceived.receiveDone.Set();}}catch(Exceptione){Console.WriteLine(e.ToString());}}复制代码　　上述代码的处理逻辑为：(1)首先处理连接的回调函数里得到的通讯套接字client，接着开始接收数据；(2)当数据发送到缓冲区中，BeginReceive方法试图从buffer数组中读取长度为buffer.length的数据块，并返回接收到的数据量bytesRead。最后接收并打印数据。　　　　除了上述方法外，还可以使用基于NetworkStream相关的异步发送和接收方法，下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。　　NetworkStream使用BeginRead和EndRead方法进行读操作，使用BeginWreite和EndWrete方法进行写操作，下面看实例：复制代码staticvoidDataHandle(TcpClientclient){TcpClienttcpClient=client;//使用TcpClient的GetStream方法获取网络流NetworkStreamns=tcpClient.GetStream();//检查网络流是否可读if(ns.CanRead){//定义缓冲区byte[]read=newbyte[1024];ns.BeginRead(read,0,read.Length,newAsyncCallback(myReadCallBack),ns);}else{Console.WriteLine("无法从网络中读取流数据");}}publicstaticvoidmyReadCallBack(IAsyncResultiar){NetworkStreamns=(NetworkStream)iar.AsyncState;byte[]read=newbyte[1024];Stringdata="";intrecv;recv=ns.EndRead(iar);data=String.Concat(data,Encoding.ASCII.GetString(read,0,recv));//接收到的消息长度可能大于缓冲区总大小，反复循环直到读完为止while(ns.DataAvailable){ns.BeginRead(read,0,read.Length,newAsyncCallback(myReadCallBack),ns);}//打印Console.WriteLine("您收到的信息是"+data);}复制代码3.3程序阻塞与异步中的同步问题　　.Net里提供了EventWaitHandle类来表示一个线程的同步事件。EventWaitHandle即事件等待句柄，他允许线程通过操作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类，分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法：(1)Rset方法：将事件状态设为非终止状态，导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞；(2)Set方法：将事件状态设为终止状态，允许一个或多个等待线程继续。该方法发送一个信号给操作系统，让处于等待的某个线程从阻塞状态转换为继续运行，即WaitOne方法的线程不在阻塞；(3)WaitOne方法：阻塞当前线程，直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止，即当其他非阻塞进程调用set方法时可以继续执行。复制代码publicstaticvoidStartListening(){//Databufferforincomingdata.byte[]bytes=newByte[1024];//Establishthelocalendpointforthesocket.//TheDNSnameofthecomputer//runningthelisteneris"host.contoso.com".//IPHostEntryipHostInfo=Dns.Resolve(Dns.GetHostName());//IPAddressipAddress=ipHostInfo.AddressList[0];IPAddressipAddress=IPAddress.Parse("127.0.0.1");IPEndPointlocalEndPoint=newIPEndPoint(ipAddress,11000);//CreateaTCP/IPsocket.Socketlistener=newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);//Bindthesockettothelocal//endpointandlistenforincomingconnections.try{listener.Bind(localEndPoint);listener.Listen(100);while(true){//Settheeventtononsignaledstate.allDone.Reset();//Startanasynchronoussockettolistenforconnections.Console.WriteLine("Waitingforaconnection");listener.BeginAccept(newAsyncCallback(AcceptCallback),listener);//Waituntilaconnectionismadebeforecontinuing.allDone.WaitOne();}}catch(Exceptione){Console.WriteLine(e.ToString());}Console.WriteLine(" PressENTERtocontinue");Console.Read();}复制代码　　上述代码的逻辑为：(1)试用了ManualRestEvent对象创建一个等待句柄，在调用BeginAccept方法前使用Rest方法允许其他线程阻塞；(2)为了防止在连接完成之前对套接字进行读写操作，务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。　　当有连接接入后系统会自动调用会调用回调函数，所以当代码执行到回调函数时说明连接已经成功，并在函数的第一句就调用Set方法让处于等待的线程可以继续执行。

linux下的网络通信程序，一定要和一个结构打交道，这个结构就是socketaddress。比如bind、connect等等函数都要使用socketaddress结构。理解socketaddress时我们要明白，其实在linux下针对于不同的socketdomain定义了一个通用的地址结构structsockaddr,它的具体定义为：{unsignedshortintsa_family;charsa_data[14];}structsockaddr其中，sa_family为调用socket()函数时的参数domain参数，sa_data为14个字符长度存储。针对于不同domain下的socket，通用地址结构又对应了不同的定义，例如一般的AF_INETdomain下，socketaddress的定义如下：structsockaddr_in{unsignedshortintsin_family;uint16_tsin_port;structin_addrsin_addr;unsignedcharsin_zero[8];//未使用}structin_addr{uint32_ts_addr;}当socket的domain不同于AF_INET时，具体的地址定义又是不同的，但是整个地址结构的大小、容量都是和通用地址结构一致的。

简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程应用层通过传输层进行数据通信时，TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了称为套接字(Socket)的接口。 区分不同应用程序进程间的网络通信和连接，主要有3个参数：通信的目的IP地址、使用的传输层协议(TCP或UDP)和使用的端口号。Socket原意是 “插座”。通过将这3个参数结合起来，与一个“插座”Socket绑定，应用层就可以和传输层通过套接字接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。 -- win API socket 本文所谈到的Socket函数如果没有特别说明，都是指的Windows Socket API。 一、WSAStartup函数 int WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData ); 使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的 Socket库中的其它Socket函数了。该函数执行成功后返回0。 例：假如一个程序要使用2.1版本的Socket,那么程序代码如下 wVersionRequested = MAKEWORD( 2, 1 ); err = WSAStartup( wVersionRequested, &wsaData ); 二、WSACleanup函数 int WSACleanup (void); 应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解除与Socket库的绑定并且释放Socket库所占用的系统资源。 三、socket函数 SOCKET socket( int af, int type, int protocol ); 应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子： struct protoent *ppe; ppe=getprotobyname("tcp"); SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto); 四、closesocket函数 int closesocket( SOCKET s ); closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。 closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。 五、send函数 int send( SOCKET s, const char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用 send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度 len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send 函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除 send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket 函数就返回SOCKET_ERROR） 注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。 六、recv函数 int recv( SOCKET s, char FAR *buf, int len, int flags ); 不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么 recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据 copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。 recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回 SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。 注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。 七、bind函数 int bind( SOCKET s, const struct sockaddr FAR *name, int namelen ); 当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的： struct sockaddr { u_short sa_family; char sa_data[14]; }; sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构： struct sockaddr_in { short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8]; }; 其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充 sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子： struct sockaddr_in saddr； saddr.sin_family = AF_INET; saddr.sin_port = htons(8888); saddr.sin_addr.s_addr = htonl(INADDR_ANY); bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))； 八、listen函数 int listen( SOCKET s, int backlog ); 服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。 九、accept函数 SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen ); 服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回 INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子： struct sockaddr_in ServerSocketAddr; int addrlen; addrlen=sizeof(ServerSocketAddr); ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen); 十、connect函数 int connect( SOCKET s, const struct sockaddr FAR *name, int namelen ); 客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子： struct sockaddr_in daddr; memset((void *)&daddr,0,sizeof(daddr)); daddr.sin_family=AF_INET; daddr.sin_port=htons(8888); daddr.sin_addr.s_addr=inet_addr("133.197.22.4"); connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr))；

作为一名开发人员我们经常会听到HTTP协议、TCP/IP协议、UDP协议、Socket、Socket长连接、Socket连接池等字眼，然而它们之间的关系、区别及原理并不是所有人都能理解清楚，这篇文章就从网络协议基础开始到Socket连接池，一步一步解释他们之间的关系。 首先从网络通信的分层模型讲起：七层模型，亦称OSI(Open System Interconnection)模型。自下往上分为：物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。所有有关通信的都离不开它，下面这张图片介绍了各层所对应的一些协议和硬件 通过上图，我知道IP协议对应于网络层，TCP、UDP协议对应于传输层，而HTTP协议对应于应用层，OSI并没有Socket，那什么是Socket，后面我们将结合代码具体详细介绍。 关于传输层TCP、UDP协议可能我们平时遇见的会比较多，有人说TCP是安全的，UDP是不安全的，UDP传输比TCP快，那为什么呢，我们先从TCP的连接建立的过程开始分析，然后解释UDP和TCP的区别。 TCP的三次握手和四次分手 我们知道TCP建立连接需要经过三次握手，而断开连接需要经过四次分手，那三次握手和四次分手分别做了什么和如何进行的。 第一次握手： 建立连接。客户端发送连接请求报文段，将SYN位置为1，Sequence Number为x；然后，客户端进入SYN_SEND状态，等待服务器的确认； 第二次握手： 服务器收到客户端的SYN报文段，需要对这个SYN报文段进行确认，设置Acknowledgment Number为x+1(Sequence Number+1)；同时，自己自己还要发送SYN请求信息，将SYN位置为1，Sequence Number为y；服务器端将上述所有信息放到一个报文段（即SYN+ACK报文段）中，一并发送给客户端，此时服务器进入SYN_RECV状态； 第三次握手： 客户端收到服务器的SYN+ACK报文段。然后将Acknowledgment Number设置为y+1，向服务器发送ACK报文段，这个报文段发送完毕以后，客户端和服务器端都进入ESTABLISHED状态，完成TCP三次握手。 完成了三次握手，客户端和服务器端就可以开始传送数据。以上就是TCP三次握手的总体介绍。通信结束客户端和服务端就断开连接，需要经过四次分手确认。 第一次分手： 主机1（可以使客户端，也可以是服务器端），设置Sequence Number和Acknowledgment Number，向主机2发送一个FIN报文段；此时，主机1进入FIN_WAIT_1状态；这表示主机1没有数据要发送给主机2了； 第二次分手： 主机2收到了主机1发送的FIN报文段，向主机1回一个ACK报文段，Acknowledgment Number为Sequence Number加1；主机1进入FIN_WAIT_2状态；主机2告诉主机1，我“同意”你的关闭请求； 第三次分手： 主机2向主机1发送FIN报文段，请求关闭连接，同时主机2进入LAST_ACK状态； 第四次分手 ：主机1收到主机2发送的FIN报文段，向主机2发送ACK报文段，然后主机1进入TIME_WAIT状态；主机2收到主机1的ACK报文段以后，就关闭连接；此时，主机1等待2MSL后依然没有收到回复，则证明Server端已正常关闭，那好，主机1也可以关闭连接了。 可以看到一次tcp请求的建立及关闭至少进行7次通信，这还不包过数据的通信，而UDP不需3次握手和4次分手。 TCP和UDP的区别 　1、TCP是面向链接的，虽然说网络的不安全不稳定特性决定了多少次握手都不能保证连接的可靠性，但TCP的三次握手在最低限度上(实际上也很大程度上保证了)保证了连接的可靠性;而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，当然也不用重发，所以说UDP是无连接的、不可靠的一种数据传输协议。　 　2、也正由于1所说的特点，使得UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UDP的实时性更好。知道了TCP和UDP的区别，就不难理解为何采用TCP传输协议的MSN比采用UDP的QQ传输文件慢了，但并不能说QQ的通信是不安全的，因为程序员可以手动对UDP的数据收发进行验证，比如发送方对每个数据包进行编号然后由接收方进行验证啊什么的，即使是这样，UDP因为在底层协议的封装上没有采用类似TCP的“三次握手”而实现了TCP所无法达到的传输效率。 关于传输层我们会经常听到一些问题 1．TCP服务器最大并发连接数是多少？ 关于TCP服务器最大并发连接数有一种误解就是“因为端口号上限为65535,所以TCP服务器理论上的可承载的最大并发连接数也是65535”。首先需要理解一条TCP连接的组成部分： 客户端IP、客户端端口、服务端IP、服务端端口 。所以对于TCP服务端进程来说，他可以同时连接的客户端数量并不受限于可用端口号，理论上一个服务器的一个端口能建立的连接数是全球的IP数*每台机器的端口数。实际并发连接数受限于linux可打开文件数，这个数是可以配置的，可以非常大，所以实际上受限于系统性能。通过#ulimit -n 查看服务的最大文件句柄数，通过ulimit -n xxx 修改 xxx是你想要能打开的数量。也可以通过修改系统参数： 2．为什么TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态？ 这是因为虽然双方都同意关闭连接了，而且握手的4个报文也都协调和发送完毕，按理可以直接回到CLOSED状态（就好比从SYN_SEND状态到ESTABLISH状态那样）；但是因为我们必须要假想网络是不可靠的，你无法保证你最后发送的ACK报文会一定被对方收到，因此对方处于LAST_ACK状态下的Socket可能会因为超时未收到ACK报文，而重发FIN报文，所以这个TIME_WAIT状态的作用就是用来重发可能丢失的ACK报文。 3．TIME_WAIT状态还需要等2MSL后才能返回到CLOSED状态会产生什么问题 通信双方建立TCP连接后，主动关闭连接的一方就会进入TIME_WAIT状态，TIME_WAIT状态维持时间是两个MSL时间长度，也就是在1-4分钟，Windows操作系统就是4分钟。进入TIME_WAIT状态的一般情况下是客户端，一个TIME_WAIT状态的连接就占用了一个本地端口。一台机器上端口号数量的上限是65536个，如果在同一台机器上进行压力测试模拟上万的客户请求，并且循环与服务端进行短连接通信，那么这台机器将产生4000个左右的TIME_WAIT Socket，后续的短连接就会产生address already in use : connect的异常，如果使用Nginx作为方向代理也需要考虑TIME_WAIT状态，发现系统存在大量TIME_WAIT状态的连接，通过调整内核参数解决。 编辑文件，加入以下内容： 然后执行 /sbin/sysctl -p 让参数生效。 net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭； net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭； net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。 net.ipv4.tcp_fin_timeout 修改系统默认的TIMEOUT时间 相关视频推荐 10道网络八股文，每道都很经典，让你在面试中逼格满满 徒手实现网络协议栈，请准备好环境，一起来写代码 学习地址：C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂 需要C/C++ Linux服务器架构师学习资料加qun812855908获取（资料包括 C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg 等），免费分享 关于TCP/IP和HTTP协议的关系，网络有一段比较容易理解的介绍：“我们在传输数据时，可以只使用(传输层)TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容。如果想要使传输的数据有意义，则必须使用到应用层协议。应用层协议有很多，比如HTTP、FTP、TELNET等，也可以自己定义应用层协议。 HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TCP/IP做传输层协议将它发到网络上。 由于HTTP在每次请求结束后都会主动释放连接，因此HTTP连接是一种“短连接”，要保持客户端程序的在线状态，需要不断地向服务器发起连接请求。通常 的做法是即时不需要获得任何数据，客户端也保持每隔一段固定的时间向服务器发送一次“保持连接”的请求，服务器在收到该请求后对客户端进行回复，表明知道 客户端“在线”。若服务器长时间无法收到客户端的请求，则认为客户端“下线”，若客户端长时间无法收到服务器的回复，则认为网络已经断开。 下面是一个简单的HTTP Post application/json数据内容的请求： 现在我们了解到TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。就像操作系统会提供标准的编程接口，比如Win32编程接口一样，TCP/IP也必须对外提供编程接口，这就是Socket。现在我们知道，Socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，Socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create，listen，accept，connect，read和write等等。 不同语言都有对应的建立Socket服务端和客户端的库，下面举例Nodejs如何创建服务端和客户端： 服务端： 服务监听9000端口 下面使用命令行发送http请求和telnet 注意到curl只处理了一次报文。 客户端 Socket长连接 所谓长连接，指在一个TCP连接上可以连续发送多个数据包，在TCP连接保持期间，如果没有数据包发送，需要双方发检测包以维持此连接(心跳包)，一般需要自己做在线维持。 短连接是指通信双方有数据交互时，就建立一个TCP连接，数据发送完成后，则断开此TCP连接。比如Http的，只是连接、请求、关闭，过程时间较短,服务器若是一段时间内没有收到请求即可关闭连接。其实长连接是相对于通常的短连接而说的，也就是长时间保持客户端与服务端的连接状态。 通常的短连接操作步骤是： 连接 数据传输 关闭连接； 而长连接通常就是： 连接 数据传输 保持连接(心跳) 数据传输 保持连接(心跳) …… 关闭连接； 什么时候用长连接，短连接？ 长连接多用于操作频繁，点对点的通讯，而且连接数不能太多情况，。每个TCP连接都需要三步握手，这需要时间，如果每个操作都是先连接，再操作的话那么处理 速度会降低很多，所以每个操作完后都不断开，次处理时直接发送数据包就OK了，不用建立TCP连接。例如：数据库的连接用长连接， 如果用短连接频繁的通信会造成Socket错误，而且频繁的Socket创建也是对资源的浪费。 什么是心跳包为什么需要： 心跳包就是在客户端和服务端间定时通知对方自己状态的一个自己定义的命令字，按照一定的时间间隔发送，类似于心跳，所以叫做心跳包。网络中的接收和发送数据都是使用Socket进行实现。但是如果此套接字已经断开（比如一方断网了），那发送数据和接收数据的时候就一定会有问题。可是如何判断这个套接字是否还可以使用呢？这个就需要在系统中创建心跳机制。其实TCP中已经为我们实现了一个叫做心跳的机制。如果你设置了心跳，那TCP就会在一定的时间（比如你设置的是3秒钟）内发送你设置的次数的心跳（比如说2次），并且此信息不会影响你自己定义的协议。也可以自己定义，所谓“心跳”就是定时发送一个自定义的结构体（心跳包或心跳帧），让对方知道自己“在线”,以确保链接的有效性。 实现： 服务端： 服务端输出结果： 客户端代码： 客户端输出结果： 如果想要使传输的数据有意义，则必须使用到应用层协议比如Http、Mqtt、Dubbo等。基于TCP协议上自定义自己的应用层的协议需要解决的几个问题： 下面我们就一起来定义自己的协议，并编写服务的和客户端进行调用： 定义报文头格式： length:000000000xxxx; xxxx代表数据的长度，总长度20,举例子不严谨。 数据表的格式: Json 服务端: 日志打印： 客户端 日志打印： 客户端定时发送自定义协议数据到服务端，先发送头数据，在发送内容数据，另外一个定时器发送心跳数据，服务端判断是心跳数据，再判断是不是头数据，再是内容数据，然后解析后再发送数据给客户端。从日志的打印可以看出客户端先后writeheader和data数据，服务端可能在一个data事件里面接收到。 这里可以看到一个客户端在同一个时间内处理一个请求可以很好的工作，但是想象这么一个场景，如果同一时间内让同一个客户端去多次调用服务端请求，发送多次头数据和内容数据，服务端的data事件收到的数据就很难区别哪些数据是哪次请求的，比如两次头数据同时到达服务端，服务端就会忽略其中一次，而后面的内容数据也不一定就对应于这个头的。所以想复用长连接并能很好的高并发处理服务端请求，就需要连接池这种方式了。 什么是Socket连接池,池的概念可以联想到是一种资源的集合，所以Socket连接池，就是维护着一定数量Socket长连接的集合。它能自动检测Socket长连接的有效性，剔除无效的连接，补充连接池的长连接的数量。从代码层次上其实是人为实现这种功能的类，一般一个连接池包含下面几个属性： 场景： 一个请求过来，首先去资源池要求获取一个长连接资源，如果空闲队列里面有长连接，就获取到这个长连接Socket,并把这个Socket移到正在运行的长连接队列。如果空闲队列里面没有，且正在运行的队列长度小于配置的连接池资源的数量，就新建一个长连接到正在运行的队列去，如果正在运行的不下于配置的资源池长度，则这个请求进入到等待队列去。当一个正在运行的Socket完成了请求，就从正在运行的队列移到空闲的队列，并触发等待请求队列去获取空闲资源，如果有等待的情况。 这里简单介绍Nodejs的Socket连接池generic-pool模块的源码。 主要文件目录结构 下面介绍库的使用： 初始化连接池 使用连接池 下面连接池的使用，使用的协议是我们之前自定义的协议。 日志打印： 这里看到前面两个请求都建立了新的Socket连接 socket_pool 127.0.0.1 9000 connect，定时器结束后重新发起两个请求就没有建立新的Socket连接了，直接从连接池里面获取Socket连接资源。 源码分析 发现主要的代码就位于lib文件夹中的Pool.js 构造函数： lib/Pool.js 可以看到包含之前说的空闲的资源队列，正在请求的资源队列，正在等待的请求队列等。 下面查看 Pool.acquire 方法 lib/Pool.js 上面的代码就按种情况一直走下到最终获取到长连接的资源，其他更多代码大家可以自己去深入了解。

找网站下载例子，debug一步一步的看，这样最有效进步最快。授鱼不如授渔

socket是个套接字功能组件，用于编写通信程序。c语言包罗万象，什么都会用到，只是你会不会用而已。

Socket,又称为套接字，Socket是计算机网络通信的基本的技术之一。如今大多数基于网络的软件，如浏览器，即时通讯工具甚至是P2P下载都是基于Socket实现的。本文会介绍一下基于TCP/IP的Socket编程，并且如何写一个客户端/服务器程序。 方法/步骤Java中的socket编程 下面的部分将通过一些示例讲解一下如何使用socket编写客户端和服务器端的程序。 注意：在接下来的示例中，我将使用基于TCP/IP协议的socket编程，因为这个协议远远比UDP/IP使用的要广泛。并且所有的socket相关的类都位于java.net包下，所以在我们进行socket编程时需要引入这个包。 写入数据 接下来就是写入请求数据，我们从客户端的socket对象中得到OutputStream对象，然后写入数据后。很类似文件IO的处理代码。 打开服务器端的socket 读取数据 通过上面得到的socket对象获取InputStream对象，然后安装文件IO一样读取数据即可。这里我们将内容打印出来。 使用socket实现一个回声服务器，就是服务器会将客户端发送过来的数据传回给客户端。

TCP/IP网络通讯开发，一般采用Socket开发。它分服务器和客户端。服务器端流程：1、创建服务器套接字---分配内存、初始化2、服务器套接字--侦听3、建立与客户端配套的客户端套接字4、与客户端通讯（可以多客户端）5、关闭、销毁服务器端相应套接字----------------客户端：1、创建客户端套接字---分配内存、初始化2、连接服务器3、与服务器通讯4、关闭、销毁客户端套接字

调用 outt.flush ();

嗯 你的理解是对的

拆分开来学，分模块分函数来学。化繁为简，各个击破。有不懂，可以多沟通互相学习；

如果你的socket协议族是AF_INET，然后类型是SOCK_STREAM,那么是通过TCP协议进行通信的，如果是SOCK_DGRAM，那么是UDP通信的，无论TCP还是UDP，都会带有IP 地址头。如果是都在本机，有可能通过127.0.0.1这个回环地址进行通信，回环地址和你的网卡不是一个设备，可能你抓错了设备，所以抓不到包，你可以尝试抓一下loop back/本地回环，这样名字的那个设备。如果你是AF_LOCAL/AF_UNIX，那么它是通过sock文件进行通信的，这个抓不到。

最简单的方法，发送方在发送完成后，close这个socket,接收方自然就会recv 0 bytes了，另外，receive程序里最好写成if (nNumRead <= 0) break;

一、TCP与UDP的区别 基于连接与无连接 　　对系统资源的要求（TCP较多，UDP少） 　　UDP程序结构较简单 　　流模式与数据报模式 　　TCP保证数据正确性，UDP可能丢包 　　TCP保证数据顺序，UDP不保证 　　 部分满足以下几点要求时，应该采用UDP 面向数据报方式 网络数据大多为短消息 　　拥有大量Client 　　对数据安全性无特殊要求 　　网络负担非常重，但对响应速度要求高 　　具体编程时的区别 socket()的参数不同 　　UDP Server不需要调用listen和accept 　　UDP收发数据用sendto/recvfrom函数 　　TCP：地址信息在connect/accept时确定 　　UDP：在sendto/recvfrom函数中每次均 需指定地址信息 　　UDP：shutdown函数无效二、man----socket 　　通过查看socket的man手册可以看到socket函数的第一个参数的值可以为下面这些值： 　　Name Purpose 　　PF_UNIX, PF_LOCAL Local communication 　　PF_INET IPv4 Internet protocols 　　PF_INET6 IPv6 Internet protocols 　　PF_IPX IPX - Novell protocols 　　PF_NETLINK Kernel user interface device 　　PF_X25 ITU-T X.25 / ISO-8208 protocol 　　PF_AX25 Amateur radio AX.25 protocol 　　PF_ATMPVC Access to raw ATM PVCs 　　PF_APPLETALK Appletalk 　　PF_PACKET Low level packet interface三、编程区别 通常我们在说到网络编程时默认是指TCP编程，即用前面提到的socket函数创建一个socket用于TCP通讯，函数参数我们通常填为SOCK_STREAM。即socket(PF_INET, SOCK_STREAM, 0)，这表示建立一个socket用于流式网络通讯。 　 SOCK_STREAM这种的特点是面向连接的，即每次收发数据之前必须通过connect建立连接，也是双向的，即任何一方都可以收发数据，协议本身提供了一些保障机制保证它是可靠的、有序的，即每个包按照发送的顺序到达接收方。 　　而SOCK_DGRAM这种是User Datagram Protocol协议的网络通讯，它是无连接的，不可靠的，因为通讯双方发送数据后不知道对方是否已经收到数据，是否正常收到数据。任何一方建立一个socket以后就可以用sendto发送数据，也可以用recvfrom接收数据。根本不关心对方是否存在，是否发送了数据。它的特点是通讯速度比较快。大家都知道TCP是要经过三次握手的，而UDP没有。 　　基于上述不同，UDP和TCP编程步骤也有些不同，如下： 　　TCP编程的服务器端一般步骤是： 　　1、创建一个socket，用函数socket()； 　　2、设置socket属性，用函数setsockopt(); * 可选 　　3、绑定IP地址、端口等信息到socket上，用函数bind(); 　　4、开启监听，用函数listen()； 　　5、接收客户端上来的连接，用函数accept()； 　　6、收发数据，用函数send()和recv()，或者read()和write(); 　　7、关闭网络连接； 　　8、关闭监听； 　　TCP编程的客户端一般步骤是： 　　1、创建一个socket，用函数socket()； 　　2、设置socket属性，用函数setsockopt();* 可选 　　3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选 　　4、设置要连接的对方的IP地址和端口等属性； 　　5、连接服务器，用函数connect()； 　　6、收发数据，用函数send()和recv()，或者read()和write(); 　　7、关闭网络连接； 　　与之对应的UDP编程步骤要简单许多，分别如下： 　　UDP编程的服务器端一般步骤是： 　　1、创建一个socket，用函数socket()； 　　2、设置socket属性，用函数setsockopt();* 可选 　　3、绑定IP地址、端口等信息到socket上，用函数bind(); 　　4、循环接收数据，用函数recvfrom(); 　　5、关闭网络连接； 　　UDP编程的客户端一般步骤是： 　　1、创建一个socket，用函数socket()； 　　2、设置socket属性，用函数setsockopt();* 可选 　　3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选 　　4、设置对方的IP地址和端口等属性; 　　5、发送数据，用函数sendto(); 　　6、关闭网络连接；

socket的send和recv是同时支持TCP和UDP的。从这两个函数的设计可以看出，协议简单来说就是读写数据。 socket的选项是 SOCK_STREAM 。 send的返回值>0时，表示实际发送了多少字节。 注意： 只是copy到系统缓存里，系统决定什么时候会发送这些数据。 send的返回值==0时，这个在send空串时会发生，是正常的。 send的返回值<0时（只会等于-1吧），需要检查errno，当 errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN 时，连接正常，可以稍后再试。其他的就是连接异常了。 recv的返回值>0时，表示实际接受到多少字节。 recv的返回值==0时， 表示连接断开 ，也就是收到了FIN或者RST。 recv的返回值<0时，检查errno，和send类似。 socket的选项是 SOCK_DGRAM 。 send的返回值>0时， 返回值应该等于发送的数据长度 。如果send的数据大于MTU，会在IP层分片，到达目标机器后IP层重组。 send的返回值==0时，这个只在发送空串时出现。 注意： 真的会发送空数据的。 send的返回值<0时，检查errno，确定连接是否还正常。一般不会发生吧，UDP的send是直接发送出去的。 recv的返回值>0时， 收到一个完整的数据包 。这个完整性是有IP层保证的。 recv的返回值==0时， 收到空包，这和TCP有很大不同 。 recv的返回值<0时，检查errno，确定socket是否正常。 PS： UDP还有两个函数 sendto 和 recvfrom 。客户端在调用connect后，才能用 send 和 recv ， 服务器端只能用 sendto 和 recvfrom 。 UDP无连接，无顺序，自然不能代替TCP。 TCP是流式协议，需要应用层确认数据是否接受完整，也不能代替UDP。 应用要同时支持两种协议，得在上层做包装。有个KCP，使用UDP模拟TCP。

mfc只是对socket进行了一些封装，大部分人做网络编程都是用的原始的socket，比如如下接口都可以在c下进行调用x0dx0a 1.socket() x0dx0a 2.bind() x0dx0a 3.connect() x0dx0a 4.listen() x0dx0a 5.accept() x0dx0a 6.send() 和recv() x0dx0a 7.sendto() 和recvfrom() x0dx0a 8.close() 和shutdown() x0dx0a 9.getpeername() x0dx0a 10.gethostname() x0dx0a这些接口是在Winsock2.h中定义的不是在mfc中定义的，你只需要包含Winsock2.h头文件和Ws2_32.lib库就可以了。

小哥，你是谁啊？

没有对recvbuf做清空设置啊。char recvbuf[100];memset(recvbuf, 0x00, 100); recv(stockcon,recvbuf,100,0);printf("%s ",recvbuf); closesocket(stockcon);

自己做，太懒惰了，这么简单的东西

这个不懂 期待内行的同学回答

#include <string.h> #include <winsock.h> #include <windows.h> #include <iostream.h> #pragma comment (lib,"ws2_32.lib") int main (int argc, char *argv[]) { int iportFrom,iportTo; int testsocket; int iopenedport = 0; struct sockaddr_in target_addr; WSADATA wsaData; WORD wVersionRequested=MAKEWORD(1,1); if (argc <= 3) { cout << "使用格式 : " << argv[0] << " 主机IP地址 开始端口号 结束端口号 " << endl; exit(1); } if (atoi (argv[2]) > atoi (argv[3])) { cout << "错误！开始端口号必须小于结束端口号" << endl; exit(1); } else { if (WSAStartup (wVersionRequested , &wsaData) ) { cout << "连接socket库失败，请检查版本号是否为1.1 " << endl; exit(1); } iportFrom=atoi (argv[2]); iportTo=atoi (argv[3]); for (int i=iportFrom; i <= iportTo; i++) { cout << "正在建立socket................................" << endl; if ((testsocket=socket (AF_INET,SOCK_STREAM,0) ) == INVALID_SOCKET) { cout << "Socket建立失败！" << endl; exit(0); } target_addr.sin_family = AF_INET; target_addr.sin_port = htons(i); target_addr.sin_addr.s_addr = inet_addr (argv[1]); cout << "正在扫描端口：" << i << endl; if (connect (testsocket, (struct sockaddr *) &target_addr, sizeof(struct sockaddr)) == SOCKET_ERROR) cout << "端口" << i << "关闭！" << endl; else { iopenedport++; cout << "端口" << i << "开放 " << endl; } } cout << "目标主机" << argv[1] << "从" << iportFrom << "--" << iportTo << "共有" << iopenedport << "个端口开放" << endl; closesocket (testsocket); WSACleanup(); } return 0; } vc6.0 下 编译

我选第一个题目，这是服务器端，用c#实现的（VS2005）： using System; using System.Collections.Generic; using System.Text; using System.Net; using System.Threading; using System.Net.Sockets; namespace conNetWorkServer { class Program { static void Main(string[] args) { Socket client; Socket ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); byte[] addbyte = { 127, 0, 0, 1 }; IPEndPoint add = new IPEndPoint(new IPAddress(addbyte), 5050); ServerSocket.Bind(add); ServerSocket.Listen(3); while (true) { Thread.Sleep(100); if ((client = ServerSocket.Accept()) != null) { Console.WriteLine("连接上...发送数据....")； byte[] message = { 49, 50, 51, 52, 53, 54, 0 }; client.Send(message); Console.WriteLine("结束.") client.Close(); break; } } } } } 这是客户端： using System; using System.Collections.Generic; using System.Text; using System.Net; using System.Threading; using System.Net.Sockets; namespace conNetWorkClient { class Program { static void Main(string[] args) { Socket Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); byte[] addbyte = { 127, 0, 0, 1 }; Server.Connect(new IPAddress(addbyte), 5050); byte[] buffer = new byte[255]; if (Server.Receive(buffer) > 0) { Console.WriteLine("连接上..."); Console.WriteLine("从服务器接收数据..."); Console.WriteLine(buffer.ToString()); Console.WriteLine("连接断开..."); Server.Disconnect(false); Server.Close(); } } } }

网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。 下面用Socket实现一个windows下的c语言socket通信例子，用客户端传递一个字符串，服务器端进行接收。 【服务器端】 #include "stdafx.h" #include <stdio.h> #include <winsock2.h> #include <winsock2.h> #define SERVER_PORT 5208 //侦听端口 void main() { WORD wVersionRequested; WSADATA wsaData; int ret, nLeft, length; SOCKET sListen, sServer; //侦听套接字，连接套接字 struct sockaddr_in saServer, saClient; //地址信息 char *ptr;//用于遍历信息的指针 //WinSock初始化 wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本 ret=WSAStartup(wVersionRequested, &wsaData); if(ret!=0) { printf("WSAStartup() failed! "); return; } //创建Socket,使用TCP协议 sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sListen == INVALID_SOCKET) { WSACleanup(); printf("socket() faild! "); return; } //构建本地地址信息 saServer.sin_family = AF_INET; //地址家族 saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序 saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址 //绑定 ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer)); if (ret == SOCKET_ERROR) { printf("bind() faild! code:%d ", WSAGetLastError()); closesocket(sListen); //关闭套接字 WSACleanup(); return; } //侦听连接请求 ret = listen(sListen, 5); if (ret == SOCKET_ERROR) { printf("listen() faild! code:%d ", WSAGetLastError()); closesocket(sListen); //关闭套接字 return; } printf("Waiting for client connecting! "); printf("Tips: Ctrl+c to quit! "); //阻塞等待接受客户端连接 while(1)//循环监听客户端，永远不停止 { length = sizeof(saClient); sServer = accept(sListen, (struct sockaddr *)&saClient, &length); if (sServer == INVALID_SOCKET) { printf("accept() faild! code:%d ", WSAGetLastError()); closesocket(sListen); //关闭套接字 WSACleanup(); return; } char receiveMessage[5000]; nLeft = sizeof(receiveMessage); ptr = (char *)&receiveMessage; while(nLeft>0) { //接收数据 ret = recv(sServer, ptr, 5000, 0); if (ret == SOCKET_ERROR) { printf("recv() failed! "); return; } if (ret == 0) //客户端已经关闭连接 { printf("Client has closed the connection "); break; } nLeft -= ret; ptr += ret; } printf("receive message:%s ", receiveMessage);//打印我们接收到的消息。 } // closesocket(sListen); // closesocket(sServer); // WSACleanup(); } 【客户端】 #include "stdafx.h" #include <stdio.h> #include <stdlib.h> #include <winsock2.h> #define SERVER_PORT 5208 //侦听端口 void main() { WORD wVersionRequested; WSADATA wsaData; int ret; SOCKET sClient; //连接套接字 struct sockaddr_in saServer; //地址信息 char *ptr; BOOL fSuccess = TRUE; //WinSock初始化 wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本 ret = WSAStartup(wVersionRequested, &wsaData); if(ret!=0) { printf("WSAStartup() failed! "); return; } //确认WinSock DLL支持版本2.2 if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2) { WSACleanup(); printf("Invalid WinSock version! "); return; } //创建Socket,使用TCP协议 sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sClient == INVALID_SOCKET) { WSACleanup(); printf("socket() failed! "); return; } //构建服务器地址信息 saServer.sin_family = AF_INET; //地址家族 saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序 saServer.sin_addr.S_un.S_addr = inet_addr("192.168.1.127"); //连接服务器 ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer)); if (ret == SOCKET_ERROR) { printf("connect() failed! "); closesocket(sClient); //关闭套接字 WSACleanup(); return; }char sendMessage[]="hello this is client message!"; ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0); if (ret == SOCKET_ERROR) { printf("send() failed! "); } else printf("client info has been sent!"); closesocket(sClient); //关闭套接字 WSACleanup(); }

分为两种模式：TCP和UDPTCP有客户端（Client）和服务端(Server)的概念，服务端指定一个ip和端口（port）并且监听是否有客户端接入，客户端通过ip+port连接到服务端，通过socket得到输入输出流，他们之间的通信都是通过流（Stream）进行的,一个服务端可以接入多个客户端，客户端之间的通信依赖于服务端的转发。UDP并没有严格的客户端和服务端的区别，你只需要建立一个socket指定你要发送的目标ip和port就行了，他是以数据包的形式发送数据（DataPacket）,数据包里面存放的是byte[],有需要的话可补充具体实现源码

我只会JAVA咋搞???

TCP连接手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在“无差别”的网络之上。建立起一个TCP连接需要经过“三次握手”：第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）HTTP连接HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。1）在HTTP 1.0中，客户端的每次请求都要求建立一次单独的连接，在处理完本次请求后，就自动释放连接。2）在HTTP 1.1中则可以在一次连接中处理多个请求，并且多个请求可以重叠进行，不需要等待一个请求结束后再发送下一个请求。由于HTTP在每次请求结束后都会主动释放连接，因此HTTP连接是一种“短连接”，要保持客户端程序的在线状态，需要不断地向服务器发起连接请求。通常的做法是即时不需要获得任何数据，客户端也保持每隔一段固定的时间向服务器发送一次“保持连接”的请求，服务器在收到该请求后对客户端进行回复，表明知道客户端“在线”。若服务器长时间无法收到客户端的请求，则认为客户端“下线”，若客户端长时间无法收到服务器的回复，则认为网络已经断开。SOCKET原理3.1套接字（socket）概念套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。应用层通过传输层进行数据通信时，TCP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了套接字(Socket)接口。应用层可以和传输层通过Socket接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。根据具体问题类型，进行步骤拆解／原因原理分析／内容拓展等。具体步骤如下：／导致这种情况的原因主要是……

就是套接字编程了。是一种流行的可以在本地，非本地机器上通信的一种方式。说白点就是网络编程，更说白点就是实现服务器与客户端，客户端与客户端通信的一种方式

先去看书吧孩子，《unix网络编程（卷1：套接字）（卷2：进程间通信）》

Socket套接字起源于美国泊克利大学.方便了开发网络应用程序.TCP面向连接的可靠传输协议,具有数据确认和数据重传机制.保证了发送数据一定能到达通信的对方.对数据完整性要求比较高的场合使用UPD协议无连接,不可靠的传输协议.不具有数据确认和数据重传机制,对数据完整性要求比较低的场合使用IP 网络中每台主机都必须有一个惟一IP地址 IP地址是个逻辑地址 因特网上的IP地址具有全球惟一性 32位,4个字节,常用点分十进制的格式表示icmp记不太清楚了 不好意思

最近也在学 还有一个自己写的C++聊天程序 有点大 下面是C写的sockets（套接字）编程有三种，流式套接字（SOCK_STREAM），数据报套接字 （SOCK_DGRAM），原始套接字（SOCK_RAW）；基于TCP的socket编程是采用的流式套接字(SOCK_STREAM)。基于UDP采 用的数据报套接字(SOCK_DGRAM).1.TCP流式套接字的编程步骤在使用之前须链接库函数：工程->设置->Link->输入ws2_32.lib，OK！服务器端程序：1、加载套接字库2、创建套接字（socket）。 3、将套接字绑定到一个本地地址和端口上（bind）。4、将套接字设为监听模式，准备接收客户请求（listen）。5、等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）。6、用返回的套接字和客户端进行通信（send/recv）。7、返回，等待另一客户请求。8、关闭套接字。客户端程序：1、加载套接字库2、创建套接字（socket）。 3、向服务器发出连接请求（connect）。4、和服务器端进行通信（send/recv）。5、关闭套接字服务器端代码如下：#include <Winsock2.h>//加裁头文件#include <stdio.h>//加载标准输入输出头文件void main(){WORD wVersionRequested;//版本号WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );//1.1版本的套接字err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) {return;}//加载套接字库，加裁失败则返回if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup( );return; }//如果不是1.1的则退出SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创建套接字（socket）。SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//转换Unsigned short为网络字节序的格式addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));//将套接字绑定到一个本地地址和端口上（bind）listen(sockSrv,5);//将套接字设为监听模式，准备接收客户请求（listen）。SOCKADDR_IN addrClient;//定义地址族int len=sizeof(SOCKADDR);//初始化这个参数，这个参数必须被初始化while(1){SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);//accept的第三个参数一定要有初始值。//等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）。//此时程序在此发生阻塞char sendBuf[100];sprintf(sendBuf,"Welcome %s to http://www.sunxin.org",inet_ntoa(addrClient.sin_addr));//用返回的套接字和客户端进行通信（send/recv）。send(sockConn,sendBuf,strlen(sendBuf)+1,0);char recvBuf[100];recv(sockConn,recvBuf,100,0);printf("%s ",recvBuf);closesocket(sockConn);//关闭套接字。等待另一个用户请求}}客户端代码如下：#include <Winsock2.h>#include <stdio.h>void main(){WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );加载套接字库if ( err != 0 ) {return;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup( );return; }SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);创建套接字（socket）。SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));向服务器发出连接请求（connect）。char recvBuf[100];和服务器端进行通信（send/recv）。recv(sockClient,recvBuf,100,0);printf("%s ",recvBuf);send(sockClient,"This is lisi",strlen("This is lisi")+1,0);closesocket(sockClient);关闭套接字。WSACleanup();//必须调用这个函数清除参数}

没事了看看也好再看看HTTP协议自己做个简单的web服务器玩玩对以后提高会有帮助

可以理解为通信模块。套接，要理解为多层之间的协调。通信在操作系统里是分层实现的。字，来自于UNIX，UNIX里所有的东西都是文件的，文件需要一个ID来表示，说的多了，ID就成字了。想学socket，请来锐英源，有丰富的工作经验结合工作经验、开源、英语、视频教学、在线教学、阶段式兴趣和实践。注重软件设计思路指导和实践，注重分析大型项目的实现，保证学会工作能力。网校是视频教学和在线交流结合的。视频通俗易懂逐渐深入，在线灵活生动结合具体代码，可以结合例子，远程协助进行指导。在郑州有面授，参与实际项目开发，保证学会工作能力。

你了解什么是socket不? 如果不了解建议去了解下,都是需要掌握的知识我大概跟你描述下流程服务器端先初始化Socket，绑定端口(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。其实网上资源很多了, 多了解多动手多你自己的进步有很大的帮助

其基本原理是：首先建立一个socket连接，然后对其进行操作，比如，从该socket读数据。因为网络传输是要一定的时间的，即使网络通畅的情况下，接受数据的操作也要花费时间。对于一个简单的单线程程序，接收数据的过程是无法处理其他操作的。比如一个窗口程序，当你接收数据时，点击按钮或关闭窗口操作都不会有效。它的缺点显而易见，一个线程你只能处理一个 socket，用来教课还行，实际使用效果就不行了。select模型 为了处理多个socket连接，聪明的人们发明了select模型。该模型以集合来管理socket连接，每次去查询集合中的socket状态，从而达到处理多连接的能力，其函数原型是int select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout)。比如我们判断某个socket是否有数据可读，我们首先将一个fdread集合置空，然后将socket加入到该集合，调用 select(0,&fdread,NULL,NULL,NULL)，之后我们判断socket是否还在fdread中，如果还在，则说明有数据可读。数据的读取和阻塞模型相同，调用recv函数。但是每个集合容量都有一个限值，默认情况下是64个，当然你可以重新定义它的大小，但还是有一个最上限，自己设置也不能超过该值，一般情况下是1024。尽管select模型可以处理多连接，但集合的管理多少让人感到繁琐。异步选择模型 熟悉windows操作系统的都知道，其窗口处理是基于消息的。人们又发明了一种新的网络模型——WSAAsyncSelect模型，即异步选择模型。该模型为每个socket绑定一个消息，当socket上出现事先设置的socket事件时，操作系统就会给应用程序发送这个消息，从而对该 socket事件进行处理，其函数原型是int WSAAsynSelect(SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent)。hWnd指明接收消息的句柄，wMsg指定消息ID，lEvent按位设置感兴趣的网络事件，入 WSAAsyncSelect(s,hwnd,WM_SOCKET, FD_CONNECT | FD_READ | FD_CLOSE)。该模型的优点是在系统开销不大的情况下同时处理许多连接，也不需要什么集合管理。缺点很明显，即使你的程序不需要窗口，也要专门为 WSAAsyncSelect模型定义一个窗口。另外，让单个窗口去处理成千上万的socket操作事件，很可能成为性能瓶颈。事件选择模型 与WSAAsynSelect模型类似，人们还发明了WSAEventSelect模型，即事件选择模型。看名字就可以猜测出来，它是基于事件的。WSAAsynSelect模型在出现感兴趣的socket事件时，系统会发一个相应的消息。而WSAEventSelect模型在出现感兴趣的socket事件时，系统会将相应WSAEVENT事件设为传信。可能你现在对sokect事件和普通WSAEVENT事件还不是很清楚。 socket事件是与socket操作相关的一些事件，如FD_READ,FD_WRITE,FD_ACCEPT等。而WSAEVENT事件是传统的事件，该事件有两种状态，传信（signaled)和未传信(non-signaled）。所谓传信，就是事件发生了，未传信就是还没有发生。我们每次建立一个连接，都为其绑定一个事件，等到该连接变化时，事件就会变为传信状态。那么，谁去接受这个事件变化呢？我们通过一个 WSAWaitForMultipleEvents（...）函数来等待事件发生，传入参数中的事件数组中，只有有一个事件发生，该函数就会返回（也可以设置为所有事件发生才返回，在这里没用），返回值为事件的数组序号，这样我们就知道了哪个事件发生了，也就是该事件对应的socket有了socket操作事件。该模型比起WSAAsynSelect模型的优势很明显，不需要窗口。唯一缺点是，该模型每次只能等待64个事件，这一限制使得在处理多 socket时，有必要组织一个线程池，伸缩性不如后面要讲的重叠模型。重叠I/O（Overlapped I/O）模型重叠I/O（Overlapped I/O）模型使应用程序达到更佳的系统性能。重叠模型的基本设计原理是让应用程序使用重叠数据结构，一次投递一个或多个Winsock I/O请求。重叠模型到底是什么东西呢？可以与WSAEventSelect模型做类比（其实不恰当，后面再说），事件选择模型为每个socket连接绑定了一个事件，而重叠模型为每个socket连接绑定了一个重叠。当连接上发生socket事件时，对应的重叠就会被更新。其实重叠的高明之处在于，它在更新重叠的同时，还把网络数据传到了实现指定的缓存区中。我们知道，前面的网络模型都要用户自己通过recv函数来接受数据，这样就降低了效率。我们打个比方，WSAEventSelect模型就像邮局的包裹通知，用户收到通知后要自己去邮局取包裹。而重叠模型就像送货上门，邮递员发给你通知时，也把包裹放到了你事先指定的仓库中。 重叠模型又分为事件通知和完成例程两种模式。在分析这两种模式之前，我们还是来看看重叠数据结构： typedef struct WSAOVERLAPPED{DWORD Internal; DWORD InternalHigh; DWORD Offset; DWORD OffsetHigh; WSAEVENT hEvent; }WSAOVERLAPPED, FAR * LPWSAOVERLAPPED; 该数据结构中，Internal、InternalHigh、Offset、OffsetHigh都是系统使用的，用户不用去管，唯一关注的就是 hEvent。如果使用事件通知模式，那么hEvent就指向相应的事件句柄。如果是完成例程模式，hEvent设为NULL。我们现在来看事件通知模式，首先创建一个事件hEvent，并创建一个重叠结构AcceptOverlapped，并设置AcceptOverlapped.hEvent = hEvent，DataBuf是我们事先设置的数据缓存区。调用 WSARecv(AcceptSocket,&DataBuf,1,&RecvBytes,&Flags,&AcceptOverlapped,NULL)，则将AcceptSocket与AcceptOverlapped重叠绑定在了一起。当接收到数据以后，hEvent就会设为传信，而数据就会放到 DataBuf中。我们再通过WSAWaitForMultipleEvents（...）接收到该事件通知。这里我们要注意，既然是基于事件通知的，那它就有一个事件处理上限，一般为64。 完成例程和事件通知模式的区别在于，当相应的socket事件出现时，系统会调用用户事先指定的回调函数，而不是设置事件。其实就是将WSARecv的最后一个参数设为函数指针。该回调函数的原型如下： void CALLBACK CompletionROUTINE( DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags);其中，cbTransferred表示传输的字节数，lpOverlapped是发生socket事件的重叠指针。我们调用 WSARecv(AcceptSocket,&DataBuf,1,&RecvBytes,&Flags,&AcceptOverlapped,WorkerRoutine) 将AcceptSocket与WorkRoutine例程绑定。这里有一点小提示，当我们创建多个socket的连接时，最好把重叠与相应的数据缓存区用一个大的数据结构放到一块，这样，我们在例程中通过lpOverlapped指针就可以直接找到相应的数据缓存区。这里要注意，不能将多个重叠使用同一个数据缓存区，这样在多个重叠都在处理时，就会出现数据混乱。完成端口模型 下面我们来介绍专门用于处理为数众多socket连接的网络模型——完成端口。因为需要做出大量的工作以便将socket添加到一个完成端口，而其他方法的初始化步骤则省事多了，所以对新手来说，完成端口模型好像过于复杂了。然而，一旦弄明白是怎么回事，就会发现步骤其实并非那么复杂。所谓完成端口，实际是Windows采用的一种I/O构造机制，除套接字句柄之外，还可以接受其他东西。使用这种模式之前，首先要创建一个I/O完成端口对象，该函数定义如下： HANDLE CreateIoCompletionPort( HANDLE FileHandle, HANDLE ExistingCompletionPort, DWORD CompletionKey, DWORD NumberOfConcurrentThreads);该函数用于两个截然不同的目的：1）用于创建一个完成端口对象。2）将一个句柄同完成端口关联到一起。 通过参数NumberOfConcurrentThreads，我们可以指定同时运行的线程数。理想状态下，我们希望每个处理器各自负责一个线程的运行，为完成端口提供服务，避免过于频繁的线程任务切换。对于一个socket连接，我们通过 CreateIoCompletionPort((HANDLE)Accept,CompletionPort, (DWORD)PerHandleData,0)将Accept连接与CompletionPort完成端口绑定到一起，CompetionPort对应的那些线程不断通过GetQueuedCompletionStatus来查询与其关联的socket连接是否有I/O操作完成，如果有，则做相应的数据处理，然后通过WSARecv将该socket连接再次投递，继续工作。完成端口在性能和伸缩性方面表现都很好，相关联的socket连接数目没有限制。

Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。请参阅以下资料：socket非常类似于电话插座。以一个国家级电话网为例。电话的通话双方相当于相互通信的 个进程，区号是它的网络地址；区内一个单位的交换机相当于一台主机，主机分配给每个用户的局内号码相当于socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。对方假如在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭socket，撤消连接。在电话系统中，一般用户只能感受到本地电话机和对方电话号码的存在，建立通话的过程，话音传输的过程以及整个电话系统的技术细节对他都是透明的，这也与socket机制非常相似。socket利用网间网通信设施实现进程通信，但它对通信设施的细节毫不关心，只要通信设施能提供足够的通信能力，它就满足了。至此，我们对socket进行了直观的描述。抽象出来，socket实质上提供了进程通信的端点。进程通信之前，双方首先必须各自创建一个端点，否则是没有法建立联系并相互通信的。正如打电话之前，双方必须各自拥有一台电话机一样。在网间网内部，每一个socket用一个半相关描述:(协议，本地地址，本地端口)一个完整的socket有一个本地唯一的socket号，由操作系统分配。最重要的是，socket是面向客户/服务器模型而设计的，针对客户和服务器程序提供不同的socket系统调用。客户随机申请一个socket(相当于一个想打电话的人可以在任何一台入网电话上拨号呼叫)，系统为之分配一个socket号；服务器拥有全局公认的socket，任何客户都可以向它发出连接请求和信息请求(相当于一个被呼叫的电话拥有一个呼叫方知道的电话号码)。socket利用客户/服务器模式巧妙地解决了进程之间建立通信连接的问题。服务器socket半相关为全局所公认非常重要。读者不妨考虑一下，两个完全随机的用户进程之间如何建立通信？假如通信双方没有任何一方的socket固定，就好比打电话的双方彼此不知道对方的电话号码，要通话是不可能的。实际应用中socket例子Socket接口是访问Internet使用得最广泛的方法。如果你有一台刚配好TCP/IP协议的主机，其IP地址是 . . . ，此时在另一台主机或同一台主机上执行ftp . . . ，显然无法建立连接。因" . . . "这台主机没有运行FTP服务软件。同样，在另一台或同一台主机上运行浏览软件如Netscape，输入"http:// . . . "，也无法建立连接。现在，如果在这台主机上运行一个FTP服务软件（该软件将打开一个Socket，并将其绑定到 端口），再在这台主机上运行一个Web服务软件（该软件将打开另一个Socket，并将其绑定到 端口）。这样，在另一台主机或同一台主机上执行ftp . . . ，FTP客户软件将通过 端口来呼叫主机上由FTP服务软件提供的Socket，与其建立连接并对话。而在netscape中输入"http:// . . . "时，将通过 端口来呼叫主机上由Web服务软件提供的Socket，与其建立连接并对话。在Internet上有很多这样的主机，这些主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，象一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供 伏交流电，有的提供 伏交流电，有的则提供有线电视节目。客户软件将插头插到不同编号的插座，就可以得到不同的服务。一个Server-Client模型程序的开发原理：服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于 以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于 的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个 以上的端口。Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket类型有两种：流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。Socket建立为了建立Socket，程序可以调用Socket函数，该函数返回一个类似于文件描述符的句柄。socket函数原型为：intsocket(intdomain,inttype,intprotocol);domain指明所使用的协议族，通常为PF_INET，表示互联网协议族（TCP/IP协议族）；type参数指定socket的类型：SOCK_STREAM或SOCK_DGRAM，Socket接口还定义了原始Socket（SOCK_RAW），允许程序使用低层协议；protocol通常赋值" "。Socket()调用返回一个整型socket描述符，你可以在后面的调用使用它。Socket描述符是一个指向内部数据结构的指针，它指向描述符表入口。调用Socket函数时，socket执行体将建立一个Socket，实际上"建立一个Socket"意味着为一个Socket数据结构分配存储空间。Socket执行体为你管理描述符表。两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。Socket数据结构中包含这五种信息。socket在测量软件中的使用也很广泛socket深层次理解Socket编程基本就是listen，accept以及send，write等几个基本的操作。对于网络编程，我们也言必称TCP/IP，似乎其它网络协议已经不存在了。对于TCP/IP，我们还知道TCP和UDP，前者可以保证数据的正确和可靠性，后者则允许数据丢失。最后，我们还知道，在建立连接前，必须知道对方的IP地址和端口号。除此，普通的程序员就不会知道太多了，很多时候这些知识已经够用了。最多，写服务程序的时候，会使用多线程来处理并发访问。我们还知道如下几个事实： 。一个指定的端口号不能被多个程序共用。比如，如果IIS占用了 端口，那么Apache就不能也用 端口了。 。很多防火墙只允许特定目标端口的数据包通过。 。服务程序在listen某个端口并accept某个连接请求后，会生成一个新的socket来对该请求进行处理。于是，一个困惑了我很久的问题就产生了。如果一个socket创建后并与 端口绑定后，是否就意味着该socket占用了 端口呢？如果是这样的，那么当其accept一个请求后，生成的新的socket到底使用的是什么端口呢（我一直以为系统会默认给其分配一个空闲的端口号）？如果是一个空闲的端口，那一定不是 端口了，于是以后的TCP数据包的目标端口就不是 了--防火墙一定会组织其通过的！实际上，我们可以看到，防火墙并没有阻止这样的连接，而且这是最常见的连接请求和处理方式。我的不解就是，为什么防火墙没有阻止这样的连接？它是如何判定那条连接是因为connet 端口而生成的？是不是TCP数据包里有什么特别的标志？或者防火墙记住了什么东西？后来，我又仔细研读了TCP/IP的协议栈的原理，对很多概念有了更深刻的认识。比如，在TCP和UDP同属于传输层，共同架设在IP层（网络层）之上。而IP层主要负责的是在节点之间（EndtoEnd）的数据包传送，这里的节点是一台网络设备，比如计算机。因为IP层只负责把数据送到节点，而不能区分上面的不同应用，所以TCP和UDP协议在其基础上加入了端口的信息，端口于是标识的是一个节点上的一个应用。除了增加端口信息，UPD协议基本就没有对IP层的数据进行任何的处理了。而TCP协议还加入了更加复杂的传输控制，比如滑动的数据发送窗口（SliceWindow），以及接收确认和重发机制，以达到数据的可靠传送。不管应用层看到的是怎样一个稳定的TCP数据流，下面传送的都是一个个的IP数据包，需要由TCP协议来进行数据重组。所以，我有理由怀疑，防火墙并没有足够的信息判断TCP数据包的信息，除了IP地址和端口号。而且，我们也看到，所谓的端口，是为了区分不同的应用的，以在不同的IP包来到的时候能够正确转发。TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。就像操作系统会提供标准的编程接口，比如Win 编程接口一样，TCP/IP也必须对外提供编程接口，这就是Socket编程接口--原来是这么回事啊！在Socket编程接口里，设计者提出了一个很重要的概念，那就是socket。这个socket跟文件句柄很相似，实际上在BSD系统里就是跟文件句柄一样存放在一样的进程句柄表里。这个socket其实是一个序号，表示其在句柄表中的位置。这一点，我们已经见过很多了，比如文件句柄，窗口句柄等等。这些句柄，其实是代表了系统中的某些特定的对象，用于在各种函数中作为参数传入，以对特定的对象进行操作--这其实是C语言的问题，在C++语言里，这个句柄其实就是this指针，实际就是对象指针啦。现在我们知道，socket跟TCP/IP并没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所以，socket的出现只是可以更方便的使用TCP/IP协议栈而已，其对TCP/IP进行了抽象，形成了几个最基本的函数接口。比如create，listen，accept，connect，read和write等等。现在我们明白，如果一个程序创建了一个socket，并让其监听 端口，其实是向TCP/IP协议栈声明了其对 端口的占有。以后，所有目标是 端口的TCP数据包都会转发给该程序（这里的程序，因为使用的是Socket编程接口，所以首先由Socket层来处理）。所谓accept函数，其实抽象的是TCP的连接建立过程。accept函数返回的新socket其实指代的是本次创建的连接，而一个连接是包括两部分信息的，一个是源IP和源端口，另一个是宿IP和宿端口。所以，accept可以产生多个不同的socket，而这些socket里包含的宿IP和宿端口是不变的，变化的只是源IP和源端口。这样的话，这些socket宿端口就可以都是 ，而Socket层还是能根据源/宿对来准确地分辨出IP包和socket的归属关系，从而完成对TCP/IP协议的操作封装！而同时，放火墙的对IP包的处理规则也是清晰明了，不存在前面设想的种种复杂的情形。

一般的教程都是说，2台机器通过套接字建立一个管道连接，然后遵循tcp/ip进行通信

1.所谓Javasocket通信通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。2.socket开发分客户端与服务端3.服务端开启服务监听某一端口4.客户端向此服务器的这个端口发出请求，成功则会建立会话，形成通道．5.这个通道若不做其它操作会一直存在，就是所谓的长连接了，这时服务端与客户端可以通过此通道进行即时通信

通过tcp/IP或者udp进行网络通讯。如果还要继续深究的话，建议你看看网络协议方面的书籍