在windows下，如何用纯C语言实现socket网络编程？

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

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

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

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包的处理规则也是清晰明了，不存在前面设想的种种复杂的情形。

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

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

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

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();//必须调用这个函数清除参数}

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

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

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接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。根据具体问题类型，进行步骤拆解／原因原理分析／内容拓展等。具体步骤如下：／导致这种情况的原因主要是……

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

我只会JAVA咋搞???

网络的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(); }

我选第一个题目，这是服务器端，用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(); } } } }

#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 下 编译

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

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

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

小哥，你是谁啊？

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库就可以了。

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。

一、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、关闭网络连接；

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

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

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

嗯 你的理解是对的

调用 outt.flush ();

winscok2.h

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

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实现一个回声服务器，就是服务器会将客户端发送过来的数据传回给客户端。

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

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

基于C#的socket编程的TCP异步实现一、摘要　　本篇博文阐述基于TCP通信协议的异步实现。二、实验平台　　Visual Studio 2010三、异步通信实现原理及常用方法3.1 建立连接　　　在同步模式中，在服务器上使用Accept方法接入连接请求，而在客户端则使用Connect方法来连接服务器。相对地，在异步模式下，服务器可以使用BeginAccept方法和EndAccept方法来完成连接到客户端的任务，在客户端则通过BeginConnect方法和EndConnect方法来实现与服务器的连接。　　BeginAccept在异步方式下传入的连接尝试，它允许其他动作而不必等待连接建立才继续执行后面程序。在调用BeginAccept之前，必须使用Listen方法来侦听是否有连接请求，BeginAccept的函数原型为：BeginAccept(AsyncCallback AsyncCallback, Ojbect state)参数：AsyncCallBack：代表回调函数state：表示状态信息，必须保证state中包含socket的句柄　　使用BeginAccept的基本流程是：(1)创建本地终节点，并新建套接字与本地终节点进行绑定；(2)在端口上侦听是否有新的连接请求；(3)请求开始接入新的连接，传入Socket的实例或者StateOjbect的实例。　　参考代码：复制代码//定义IP地址IPAddress local = IPAddress.Parse("127.0,0,1");IPEndPoint iep = new IPEndPoint(local,13000);//创建服务器的socket对象Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);server.Bind(iep);server.Listen(20);server.BeginAccecpt(new AsyncCallback(Accept),server);复制代码　　当BeginAccept()方法调用结束后，一旦新的连接发生，将调用回调函数，而该回调函数必须包括用来结束接入连接操作的EndAccept()方法。该方法参数列表为 Socket EndAccept(IAsyncResult iar)下面为回调函数的实例：复制代码void Accept(IAsyncResult iar){ //还原传入的原始套接字 Socket MyServer = (Socket)iar.AsyncState; //在原始套接字上调用EndAccept方法，返回新的套接字 Socket service = MyServer.EndAccept(iar);}复制代码　　至此，服务器端已经准备好了。客户端应通过BeginConnect方法和EndConnect来远程连接主机。在调用BeginConnect方法时必须注册相应的回调函数并且至少传递一个Socket的实例给state参数，以保证EndConnect方法中能使用原始的套接字。下面是一段是BeginConnect的调用：Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)IPAddress ip=IPAddress.Parse("127.0.0.1");IPEndPoint iep=new IPEndPoint(ip,13000);socket.BeginConnect(iep, new AsyncCallback(Connect),socket);　　EndConnect是一种阻塞方法，用于完成BeginConnect方法的异步连接诶远程主机的请求。在注册了回调函数后必须接收BeginConnect方法返回的IASynccReuslt作为参数。下面为代码演示：复制代码void Connect(IAsyncResult iar){ Socket client=(Socket)iar.AsyncState; try { client.EndConnect(iar); } catch (Exception e) { Console.WriteLine(e.ToString()); } finally { }}复制代码　　除了采用上述方法建立连接之后，也可以采用TcpListener类里面的方法进行连接建立。下面是服务器端对关于TcpListener类使用BeginAccetpTcpClient方法处理一个传入的连接尝试。以下是使用BeginAccetpTcpClient方法和EndAccetpTcpClient方法的代码：复制代码public static void DoBeginAccept(TcpListener listner){ //开始从客户端监听连接 Console.WriteLine("Waitting for a connection"); //接收连接 //开始准备接入新的连接，一旦有新连接尝试则调用回调函数DoAcceptTcpCliet listner.BeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpCliet), listner);}//处理客户端的连接public static void DoAcceptTcpCliet(IAsyncResult iar){ //还原原始的TcpListner对象 TcpListener listener = (TcpListener)iar.AsyncState; //完成连接的动作，并返回新的TcpClient TcpClient client = listener.EndAcceptTcpClient(iar); Console.WriteLine("连接成功");}复制代码　　代码的处理逻辑为：(1)调用BeginAccetpTcpClient方法开开始连接新的连接，当连接视图发生时，回调函数被调用以完成连接操作；(2)上面DoAcceptTcpCliet方法通过AsyncState属性获得由BeginAcceptTcpClient传入的listner实例；(3)在得到listener对象后，用它调用EndAcceptTcpClient方法，该方法返回新的包含客户端信息的TcpClient。　　BeginConnect方法和EndConnect方法可用于客户端尝试建立与服务端的连接，这里和第一种方法并无区别。下面看实例：复制代码public void doBeginConnect(IAsyncResult iar){ Socket client=(Socket)iar.AsyncState; //开始与远程主机进行连接 client.BeginConnect(serverIP[0],13000,requestCallBack,client); Console.WriteLine("开始与服务器进行连接");}private void requestCallBack(IAsyncResult iar){ try { //还原原始的TcpClient对象 TcpClient client=(TcpClient)iar.AsyncState; // client.EndConnect(iar); Console.WriteLine("与服务器{0}连接成功",client.Client.RemoteEndPoint); } catch(Exception e) { Console.WriteLine(e.ToString()); } finally { }}复制代码　　以上是建立连接的两种方法。可根据需要选择使用。3.2 发送与接受数据　　在建立了套接字的连接后，就可以服务器端和客户端之间进行数据通信了。异步套接字用BeginSend和EndSend方法来负责数据的发送。注意在调用BeginSend方法前要确保双方都已经建立连接，否则会出异常。下面演示代码：复制代码private static void Send(Socket handler, String data){ // Convert the string data to byte data using ASCII encoding. byte[] byteData = Encoding.ASCII.GetBytes(data); // Begin sending the data to the remote device. handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);}private static void SendCallback(IAsyncResult ar){ try { // Retrieve the socket from the state object. Socket handler = (Socket)ar.AsyncState; // Complete sending the data to the remote device. int bytesSent = handler.EndSend(ar); Console.WriteLine("Sent {0} bytes to client.", bytesSent); handler.Shutdown(SocketShutdown.Both); handler.Close(); } catch (Exception e) { Console.WriteLine(e.ToString()); }}复制代码　　接收数据是通过BeginReceive和EndReceive方法：复制代码private static void Receive(Socket client){ try { // Create the state object. StateObject state = new StateObject(); state.workSocket = client; // Begin receiving the data from the remote device. client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); } catch (Exception e) { Console.WriteLine(e.ToString()); }}private static void ReceiveCallback(IAsyncResult ar){ try { // Retrieve the state object and the client socket // from the asynchronous state object. StateObject state = (StateObject)ar.AsyncState; Socket client = state.workSocket; // Read data from the remote device. int bytesRead = client.EndReceive(ar); if (bytesRead > 0) { // There might be more data, so store the data received so far. state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead)); // Get the rest of the data. client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); } else { // All the data has arrived; put it in response. if (state.sb.Length > 1) { response = state.sb.ToString(); } // Signal that all bytes have been received. receiveDone.Set(); } } catch (Exception e) { Console.WriteLine(e.ToString()); }}复制代码　　上述代码的处理逻辑为：(1)首先处理连接的回调函数里得到的通讯套接字client，接着开始接收数据；(2)当数据发送到缓冲区中，BeginReceive方法试图从buffer数组中读取长度为buffer.length的数据块，并返回接收到的数据量bytesRead。最后接收并打印数据。　　　　除了上述方法外，还可以使用基于NetworkStream相关的异步发送和接收方法，下面是基于NetworkStream相关的异步发送和接收方法的使用介绍。　　NetworkStream使用BeginRead和EndRead方法进行读操作，使用BeginWreite和EndWrete方法进行写操作，下面看实例：复制代码static void DataHandle(TcpClient client){ TcpClient tcpClient = client; //使用TcpClient的GetStream方法获取网络流 NetworkStream ns = tcpClient.GetStream(); //检查网络流是否可读 if(ns.CanRead) { //定义缓冲区 byte[] read = new byte[1024]; ns.BeginRead(read,0,read.Length,new AsyncCallback(myReadCallBack),ns); } else { Console.WriteLine("无法从网络中读取流数据"); }}public static void myReadCallBack(IAsyncResult iar){ NetworkStream ns = (NetworkStream)iar.AsyncState; byte[] read = new byte[1024]; String data = ""; int recv; recv = ns.EndRead(iar); data = String.Concat(data, Encoding.ASCII.GetString(read, 0, recv)); //接收到的消息长度可能大于缓冲区总大小，反复循环直到读完为止 while (ns.DataAvailable) { ns.BeginRead(read, 0, read.Length, new AsyncCallback(myReadCallBack), ns); } //打印 Console.WriteLine("您收到的信息是" + data);}复制代码3.3 程序阻塞与异步中的同步问题　　.Net里提供了EventWaitHandle类来表示一个线程的同步事件。EventWaitHandle即事件等待句柄，他允许线程通过操作系统互发信号和等待彼此的信号来达到线程同步的目的。这个类有2个子类，分别为AutoRestEevnt(自动重置)和ManualRestEvent(手动重置)。下面是线程同步的几个方法：(1)Rset方法：将事件状态设为非终止状态，导致线程阻塞。这里的线程阻塞是指允许其他需要等待的线程进行阻塞即让含WaitOne()方法的线程阻塞；(2)Set方法：将事件状态设为终止状态，允许一个或多个等待线程继续。该方法发送一个信号给操作系统，让处于等待的某个线程从阻塞状态转换为继续运行，即WaitOne方法的线程不在阻塞；(3)WaitOne方法：阻塞当前线程，直到当前的等待句柄收到信号。此方法将一直使本线程处于阻塞状态直到收到信号为止，即当其他非阻塞进程调用set方法时可以继续执行。复制代码public static void StartListening(){ // Data buffer for incoming data. byte[] bytes = new Byte[1024]; // Establish the local endpoint for the socket. // The DNS name of the computer // running the listener is "host.contoso.com". //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); //IPAddress ipAddress = ipHostInfo.AddressList[0]; IPAddress ipAddress = IPAddress.Parse("127.0.0.1"); IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000); // Create a TCP/IP socket. Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp); // Bind the socket to the local //endpoint and listen for incoming connections. try { listener.Bind(localEndPoint); listener.Listen(100); while (true) { // Set the event to nonsignaled state. allDone.Reset(); // Start an asynchronous socket to listen for connections. Console.WriteLine("Waiting for a connection..."); listener.BeginAccept(new AsyncCallback(AcceptCallback),listener); // Wait until a connection is made before continuing. allDone.WaitOne(); } } catch (Exception e) { Console.WriteLine(e.ToString()); } Console.WriteLine(" Press ENTER to continue..."); Console.Read();}复制代码　　上述代码的逻辑为：(1)试用了ManualRestEvent对象创建一个等待句柄，在调用BeginAccept方法前使用Rest方法允许其他线程阻塞；(2)为了防止在连接完成之前对套接字进行读写操作，务必要在BeginAccept方法后调用WaitOne来让线程进入阻塞状态。　　当有连接接入后系统会自动调用会调用回调函数，所以当代码执行到回调函数时说明连接已经成功，并在函数的第一句就调用Set方法让处于等待的线程可以继续执行

作为一名开发人员我们经常会听到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 上面的代码就按种情况一直走下到最终获取到长连接的资源，其他更多代码大家可以自己去深入了解。

简单的说就是通信的两方的一种约定，用套接字中的相关函数来完成通信过程应用层通过传输层进行数据通信时，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))；

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时，具体的地址定义又是不同的，但是整个地址结构的大小、容量都是和通用地址结构一致的。

基于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方法让处于等待的线程可以继续执行。

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

　　下面大概分几个方面进行罗列：　　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。

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

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

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

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，这两者通常转换使用；

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

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

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

1、要实现网络编程，首先得了解网络编程的原理。大部分网络编程底层都是通过TCP/IP或者UDP协议进行通讯，不管是TCP还是UDP通讯，都是通过调用socket实现的。Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。Socket通讯分为两部分：服务器端和客户端，服务器端监听客户端的连接，连接上之后，实现数据通讯，流程2、用C语言调用Socket实现通讯服务器端示例代码如下:#include#include#include#include#include#include#include#include#definePORT1500//端口号#defineBACKLOG5/*最大监听数*/intmain(){intsockfd,new_fd;/*socket句柄和建立连接后的句柄*/structsockaddr_inmy_addr;/*本方地址信息结构体，下面有具体的属性赋值*/structsockaddr_intheir_addr;/*对方地址信息*/intsin_size;sockfd=socket(AF_INET,SOCK_STREAM,0);//建立socketif(sockfd==-1){printf("socketfailed:%d