网络Socket编程及实例

1 TCP和UDP介绍

在介绍TCP和UDP之前，有必要先介绍下网络体系结构的各个层次。

1.1  网络体系结构

协议：控制网络中信息的发送和接收。定义了通信实体之间交换报文的格式和次序，以及在报文传输或接收或其他事件所采取的动作。

一般把网络的层次结构和每层所使用协议的集合称为网络体系结构(NetworkArchitecture)。

由国际标准化组织ISO 在1981年提出的网络分层结构，简称为OSI参考模型。(Open Systems Interconnection Reference Model)。

各层协议如下，可以看出TCP和UDP协议在传输层。

各层功能

1）链路层

链路层的功能：是把接收到的网络层数据报（也 称IP数据报）通过该层的物理接口发送到传输介质上，或从物理网络上接收数据帧，抽出IP数据报并交给IP层。

链路层通常包括操作系统中的设备驱动程序和计算机中对应的网络接口卡。

2）网络层

主要功能：是可以把源主机上的分组发送到互联网中的任何一台目标主机上。

3）传输层

为运行在不同主机上的应用进程提供逻辑通信功能（主机好像是直接相连的）。

进程之间使用逻辑通信功能彼此发送报文，无需考虑具体物理链路。

传输层主要包括种协议：传输控制协议（TCP），用户数据报协议（UDP）。

4）应用层

应用层向使用网络的用户提供特定的、常用的应用程序。

表示层：通信用户之间数据格式的转换、数据压缩及加解密等。

会话层：对数据传输进行管理，包括数据交换的定界、同步，建立检查点等。

1.2 套接字

套接字是从网络向进程传递数据，或从进程向网络传递数据的门户。传输层和应用层的进程通过套接字来传递数据。

主机上的套接字可以有多个，每个套接字都有惟一的标识符（格式取决于UDP或TCP）。

当报文段到达主机时，运输层检查报文段中的目的端口号，将其定向到相应的套接字。

1.3  用户数据报协议UDP

用户数据报协议UDP（User Datagram Protocol）：提供用户之间的不可靠、无连接的报文传输服。使用UDP协议的原因

1）无连接创建（减少时延）

2）简单：无连接（在UDP发送方和接收方之间无握手）

3）段首部小

4）无拥塞控制: UDP能够尽可能快地传输

经UDP的可靠传输 : 在应用层增加可靠性，实现特定的差错恢复！

1.4 传输控制协议TCP

传输控制协议TCP（Transmission Control Protocol）：提供用户之间可靠的、面向连接的报文传输服务。

面向连接、可靠的服务是指在进行数据交换前，初始化发送方与接收方状态，进行握手（交换控制信息）。

建立一个TCP 连接的作用：让发送方和接收方都做好准备，准备好之后就要开始进行数据传输了。三次握手建立TCP连接

三次握手的目的主要在于同步连接双方发送数据的初始序列号。

TCP 连接是一种全双工的连接，即一个TCP 连接的两个端点之间可以同时发送和接收数据，而不是每一个时刻只能有一个端点发送数据。

1.5 TCP与UDP的比较

TCP与UDP特点比较

TCP 是一种面向连接的协议，而UDP 是无连接的协议。
TCP 提供的是可靠的传输服务，而UDP 协议提供的是不可靠的服务。
TCP 提供的是面向字节流的服务。
UDP 协议的传输单位是数据块，一个数据块只能封装在一个UDP 数据包中。

解释：

1）可靠、连接

UDP不可靠、无连接：在UDP发送方和接收方之间无握手（交换控制信息）。

面向连接举例：两个人之间通过电话进行通信;

面向无连接举例：邮政服务，用户把信函放在邮件中期待邮政处理流程来传递邮政包裹。显然，不可达代表不可靠。

2）TCP面向字节流和UDP面向数据块（面向报文）

面向报文的传输方式是应用层交给UDP多长的报文，UDP就照样发送，即一次发送一个报文。因此，应用程序必须选择合适大小的报文。若报文太长，则IP层需要分片，降低效率。若太短，会使IP太小。UDP对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。这也就是说，应用层交给UDP多长的报文，UDP就照样发送，即一次发送一个报文。
       面向字节流的话，虽然应用程序和TCP的交互是一次一个数据块（大小不等），但TCP把应用程序看成是一连串的无结构的字节流。TCP有一个缓冲，当应用程序传送的数据块太长，TCP就可以把它划分短一些再传送。如果应用程序一次只发送一个字节，TCP也可以等待积累有足够多的字节后再构成报文段发送出去。

TCP 协议与UDP协议应用的比较

TCP 协议对于有大量数据需要进行可靠传输的应用是很适合的。比如可用于文件传输协议（FTP ）。
对于虽然数据量少但需要时间较长且可靠性要求高的应用TCP 也是比较适合的。 Telnet 就是这种应用的一个例子。
实时应用适合使用UDP 协议。
对于多个实体间的多播式应用无法使用TCP 进行通信 。

从程序实现的角度，TCP与UDP的过程如下

从上图也能清晰的看出，TCP通信需要服务器端侦听listen、接收客户端连接请求accept，等待客户端connect建立连接后才能进行数据包的收发（recv/send）工作。而UDP则服务器和客户端的概念不明显，服务器端即接收端需要绑定端口，等待客户端的数据的到来。后续便可以进行数据的收发（recvfrom/sendto）工作。

2 JAVA代码

在JAVA中TCP套接字由Socket类实现，UDP套接字由DatagramSocket类实现。

2.1 TCP的JAVA代码大致如下

TCP网络编程步骤
1）创建Socket
2）打开连接到socket的输入、输出流
3）按照一定的协议对socket进行读、写操作（接收消息-处理数据-发送消息）
4）关闭socket

服务端代码

[java] view plain copy

  1. <span style="font-size:14px;">  public static start(){
  2. ServerSocket serverSocket=null;
  3. try {
  4. int i=1;
  5. //1、创建TCP套接字
  6. int maxConnection="10";   //最大连接数
  7. serverSocket = new java.net.ServerSocket(8189,maxConnection);
  8. //等待连接
  9. Socket sct=serverSocket.accept();
  10. //输入输出流
  11. InputStream inStream = clientSocket.getInputStream();
  12. BufferedReader in = new BufferedReader(new InputStreamReader(inStream));
  13. OutputStream outStream = clientSocket.getOutputStream();
  14. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));
  15. //接收消息-处理数据-发送消息
  16. //接收客户端消息
  17. String response="",lineStr = in.readLine();
  18. while(lineStr!=null){
  19. response += lineStr;
  20. lineStr = in.readLine();
  21. }//end while
  22. //TODO 处理消息等及其动作
  23. //向客户端发送信息（output-write）
  24. out.wirte("TODO");
  25. }
  26. catch (Exception e)
  27. {
  28. e.printStackTrace();
  29. }
  30. finally{
  31. if(serverSocket!=null)   //关闭套接字
  32. serverSocket.close();
  33. }
  34. }//end start()</span>

客户端代码与服务端代码类似，只不过服务端对客户端的请求是accept，而客户端需要连接服务端，所以使用connect方法，如下

[java] view plain copy

  1. <span style="font-size:14px;">  public static start(){
  2. ServerSocket serverSocket=null;
  3. try {
  4. int i=1;
  5. ////打开套接字
  6. Socket clientSocket = new Socket(String serverMachineIp, int port);
  7. int timeout=1000;
  8. clientSocket.connect(sa, timeout);
  9. //输入输出流
  10. InputStream inStream = clientSocket.getInputStream();
  11. BufferedReader in = new BufferedReader(new InputStreamReader(inStream));
  12. OutputStream outStream = clientSocket.getOutputStream();
  13. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));
  14. //接收消息-处理数据-发送消息
  15. /向客户端发送信息（output-write）
  16. out.wirte("TODO");
  17. //TODO 处理消息等及其动作
  18. //返回服务端的消息
  19. String response="",lineStr = in.readLine();
  20. while(lineStr!=null){
  21. response += lineStr;
  22. lineStr = in.readLine();
  23. }//end while
  24. }
  25. catch (Exception e)
  26. {
  27. e.printStackTrace();
  28. }
  29. finally{
  30. if(serverSocket!=null)   //关闭套接字
  31. serverSocket.close();
  32. }
  33. }//end start()</span>

2.1 UDP的JAVA代码大致如下

服务端代码

[java] view plain copy

  1. <span style="font-size:14px;">public class ServerDatagramSocket
  2. {
  3. public static void main(String[] args)
  4. {
  5. try
  6. {
  7. //1创建套接字，监听某个端口
  8. DatagramSocket ds = new DatagramSocket(10010);
  9. //2接收数据
  10. //构造缓冲数组,用于存放接收到的数据(要求该长度必须大于或等于接收到的数据长度)
  11. byte[] data=new byte[1024];
  12. //构造数据包对象
  13. DatagramPacket receiveDp=new DatagramPacket(data, data.length);
  14. //接收数据
  15. ds.receive(receiveDp);
  16. //输出接收到的数据内容
  17. byte[] receiveByte=receiveDp.getData();
  18. String receiveContent=new String(receiveByte,0,receiveByte.length);
  19. //3发送数据
  20. //准备数据
  21. //获得客户端的IP
  22. InetAddress clientIp=receiveDp.getAddress();
  23. //获得客户端的端口号
  24. int port=receiveDp.getPort();
  25. String sendContent="hello back";
  26. byte[] sendByte=sendContent.getBytes();
  27. DatagramPacket sendDp=new DatagramPacket(sendByte, sendByte.length, clientIp, port);
  28. ds.send(sendDp);
  29. }
  30. catch (Exception e) {
  31. // TODO: handle exception
  32. }
  33. finally{
  34. //4关闭连接
  35. ds.close();
  36. }
  37. }
  38. }</span>

客户端代码

[java] view plain copy

  1. <span style="font-size:14px;">public static void main(String[] args) {
  2. try
  3. {
  4. //1创建连接
  5. DatagramSocket ds=new DatagramSocket();
  6. //2发送数据
  7. //数据准备（数据内容+地址+端口号）
  8. String sendContent="hello";
  9. String host="127.0.0.1";
  10. int port=10001;
  11. //将发送的内容转换为字节数组
  12. byte[] sendByte=sendContent.getBytes();
  13. //将服务器IP转换为InetAddress对象
  14. InetAddress server=InetAddress.getByName(host);
  15. //构造发送的数据包对象
  16. DatagramPacket sendDp=new DatagramPacket(sendByte, sendByte.length, server, port);
  17. //发送数据
  18. ds.send(sendDp);
  19. //3接收数据
  20. //构造缓冲数组,用于存放接收到的数据(要求该长度必须大于或等于接收到的数据长度)
  21. byte[] data=new byte[1024];
  22. //构造数据包对象
  23. DatagramPacket receiveDp=new DatagramPacket(data, data.length);
  24. //接收数据
  25. ds.receive(receiveDp);
  26. //输出数据内容
  27. byte[] receiveByte=receiveDp.getData();   //获得缓冲数组
  28. int len=receiveDp.getLength();   //获得有效数据长度
  29. String receiveContent=new String(receiveByte, 0, len);
  30. System.out.println(receiveContent);
  31. }
  32. catch (Exception e)
  33. {
  34. // TODO: handle exception
  35. }
  36. finally{
  37. //4关闭连接
  38. ds.close();
  39. }
  40. }
  41. }</span>

3 应用（TCP和多线程的应用）

在工作中遇到如下问题：一个算法执行程序可以部署到多台机器上，一台机器上可以部署多个算法执行程序，即算法程序和机器是多对多的关系。现在要求用户只需要输入提供算法的名称和相关算法参数（如数据路径），然后返回数据处理结果。

解决方案：

服务端为多台部署算法程序的机器。客户端响应用户算法的请求，并从服务端多台机器中选择最优机器执行用户的算法处理。由于一台服务端机器可能会同时处理多个用户算法请求，而每个算法处理数据的过程（数据下载，数据处理，处理结果上传）是个比较长的时间，所以服务端程序采用多线程并行执行多个算法的请求。这个用一个共享FTP来在服务端和客户端共享处理的数据和上传处理后的数据。服务端和客户端通过TCP协议保证可靠的、面向连接的通信服务。整个系统架构如下图

实现代码的关键部分如下
服务端代码

[java] view plain copy

  1. /*
  2. 服务器端模块功能：
  3. 运行在多台服务端机器上面，监听和接收客户端机器发送的多个算法请求；
  4. 业务逻辑：
  5. 根据接收到的算法请求参数，启动一个新的线程，运行算法处理程序，完成最终的数据处理任务
  6. */
  7. public class ServerSocketApplication {
  8. /**
  9. * @param args
  10. */
  11. public static void main(String[] args) {
  12. start();
  13. }//end main()
  14. public static start(){
  15. ServerSocket serverSocket=null;
  16. ExecutorService threadPool=null; //用线程池管理线程
  17. try {
  18. //1、创建TCP套接字
  19. int maxConnection="10";   //最大连接数
  20. serverSocket = new ServerSocket(8189,maxConnection);
  21. while(true)  {  //while循环,不停等待算法任务的请求.服务端每接到一个算法处理请求，就开启一个线程处理该请求
  22. //等待连接
  23. Socket sct=serverSocket.accept();
  24. //Create a work thread to deal with a socket request
  25. //创建一个线程池
  26. //获得可用的处理器个数Runtime.getRuntime().availableProcessors()
  27. // int threadPoolSize=Runtime.getRuntime().availableProcessors() +1;
  28. //  ExecutorService threadPool= Executors.newFixedThreadPool(threadPoolSize);
  29. threadPool= Executors.newCachedThreadPool();
  30. //将线程放入线程池中
  31. LogicThread logicThread = new LogicThread( sct );
  32. Thread thd = new Thread( logicThread );
  33. threadPool.execute(thd);
  34. }   //end while
  35. }
  36. catch (Exception e)
  37. {
  38. e.printStackTrace();
  39. }
  40. finally{
  41. if(threadPool!=null)
  42. threadPool.shutdown(); //关闭线程池
  43. if(serverSocket!=null)   //关闭套接字
  44. serverSocket.close();
  45. }
  46. }//end start()
  47. }//end class ServerSocketApplication

[java] view plain copy

  1. //-----------------------------------
  2. //LogicThread的任务是具体负责一次算法执行任务的处理，流程：
  3. //1.解析客户端发送的算法请求参数 2. 根据请求参数中的算法名称和类型，调用具体某个算法
  4. public class LogicThread implements Runnable {
  5. private Socket  clientSocket = null;
  6. public LogicThread( ){
  7. }
  8. /**
  9. * Constructor
  10. * @param sck
  11. */
  12. public LogicThread( Socket clientSocket){
  13. this.clientSocket = clientSocket;
  14. }
  15. public void run(){
  16. clientContentHandle();
  17. }//end run()
  18. /**
  19. * 接收客户端消息，处理客户端消息，发送消息到客户端
  20. * @param clientContent 发送的消息
  21. * @param serverMachineIp 目标服务器地址
  22. * @param port 目标服务器监听端口
  23. * @return   返回的消息
  24. */
  25. private static void clientContentHandle() throws Exception{
  26. InputStream inStream = clientSocket.getInputStream();
  27. BufferedReader in = new BufferedReader(new InputStreamReader(inStream));
  28. OutputStream outStream = clientSocket.getOutputStream();
  29. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));
  30. try{
  31. //接收客户端消息
  32. String response="",lineStr = in.readLine();
  33. while(lineStr!=null){
  34. response += lineStr;
  35. lineStr = in.readLine();
  36. }//end while
  37. //TODO 处理消息
  38. //如根据客户端发送的算法请求及其参数，调用对应的算法开始处理数据，并将处理结果上传到FTP
  39. //向服务端发送信息（output-write）
  40. out.wirte("successfull"); //处理完通知客户端
  41. }
  42. catch (Exception e)
  43. {
  44. e.printStackTrace();
  45. }
  46. finally{
  47. //关闭输入输出流
  48. out.close();
  49. in.close();
  50. //关闭套接字
  51. s.close();
  52. }
  53. //处理服务端返回消息（这里直接返回）
  54. return response;
  55. }//end clientContentHandle()
  56. }//end class LogicThread

客户端代码

[java] view plain copy

  1. /*
  2. 客户端模块功能：选择算法程序所在的最优的服务端机器，向该服务器端机器发送算法调用请求；
  3. */
  4. public class ClientSocketApplication {
  5. public static void main(String[] args)
  6. {
  7. //处理服务端返回消息
  8. String response=sendMsg("10.3.11.33",9090);
  9. if(response==null)
  10. System.out.println("Socket服务器连接失败：请检查安装的Socket服务器是否正常工作!");
  11. processData("send algorithem name and its parameters");//此处省略掉算法的名称和其参数
  12. }//end main()
  13. /**
  14. * 向指定的服务器发送信息，并接收返回结果
  15. * @param sendContent 发送的消息
  16. * @param serverMachineIp 目标服务器地址
  17. * @param port 目标服务器监听端口
  18. * @return   返回的消息
  19. */
  20. public static String sendMsg(String sendContent, String serverMachineIp, int port) throws Exception{
  21. //服务端消息返回结果
  22. String response=null;
  23. //打开套接字
  24. Socket clientSocket = new Socket(String serverMachineIp, int port);
  25. int timeout=1000;
  26. clientSocket.connect(sa, timeout);
  27. OutputStream outStream = clientSocket.getOutputStream();
  28. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));
  29. InputStream inStream = clientSocket.getInputStream();
  30. BufferedReader in = new BufferedReader(new InputStreamReader(inStream));
  31. try{
  32. //向服务端发送信息（output-write）
  33. out.wirte(sendContent);
  34. //接收服务端返回消息
  35. String lineStr = in.readLine();
  36. while(lineStr!=null){
  37. response += lineStr;
  38. lineStr = in.readLine();
  39. }//end while
  40. }
  41. catch (Exception e)
  42. {
  43. e.printStackTrace();
  44. }
  45. finally{
  46. //关闭输入输出流
  47. out.close();
  48. in.close();
  49. //关闭套接字
  50. s.close();
  51. }
  52. //处理服务端返回消息（这里直接返回）
  53. return response;
  54. }//end sendMsg()
  55. /*
  56. */
  57. /** 监听服务端处理数据过程
  58. 客户端选择最优的服务端处理机器
  59. 客户端将算法名称及其参数（如要处理数据的地址）发送给服务端
  60. 客户端监听服务端发回的消息，判断数据是否处理完成，如果完成打包下载处理结果（服务端数据处理完会上传处理结果和日志文件log.xml到共享FTP上，供客户端下载）
  61. * @param algName
  62. *            请求算法资源名称
  63. * @param reqValues
  64. *            请求参数
  65. * @return 算法返回结果，无结果返回<code>null</code>
  66. */
  67. public static void processData(String algName, Map<String, String> reqValues) throws ManagerException
  68. {
  69. //一个算法可以部署到不同的机器上，这里随机选择一台部署该算法的机器(在具体开发中应该根据资源占用情况选择等因素，采用高响应比调度算法分配资源)
  70. CMachine optCMachine=getOptCMachine(algName);
  71. String sendRequest=createReqStr(algName, reqValues);  // 生成算法资源请求文件
  72. // 发送Socket连接，并等待返回结果
  73. try {
  74. String response = sendMsg(reqStr, optCMachine.getIp(),optCMachine.getPort());
  75. if ( !response.eques("processing") || !response.eques("successfull")) {  //如果服务端返回的消息是正在处理数据或处理成功，则正常，否则服务端出现异常
  76. throw new ManagerException("向服务器发送计算请求失败: " + response);
  77. }
  78. // 开始循环监视工作目录，是否已经完成处理，标识为有log.xml文件
  79. String monitDir = FileTool.getNodeManagerShareDir() + "/" + jobID + "/" + algName + "/output";
  80. File logFile = new File(monitDir + "/log.xml");
  81. for (;;) {
  82. if (logFile.exists()) {
  83. logger.info("Log文件已经上传，算法处理完成; 开始打包文件");
  84. ZipTool.zipFiles(monitDir); //打包文件
  85. break;
  86. } else {
  87. Thread.sleep(30000);
  88. logger.info("请求正在处理中...: " + algName);
  89. }
  90. }
  91. } catch (Exception e) {
  92. throw new ManagerException("算法服务器处理请求时出错，请与节点管理员联系查看原因");
  93. }
  94. }//end processData()
  95. }//end ClientSocket

原文地址：https://www.cnblogs.com/klb561/p/9011615.html

时间： 2024-10-17 16:53:10

网络Socket编程及实例的相关文章

java网络socket编程详解

7.2 面向套接字编程    我们已经通过了解Socket的接口,知其所以然,下面我们就将通过具体的案例,来熟悉Socket的具体工作方式 7.2.1使用套接字实现基于TCP协议的服务器和客户机程序    依据TCP协议,在C/S架构的通讯过程中,客户端和服务器的Socket动作如下: 客户端: 1.用服务器的IP地址和端口号实例化Socket对象. 2.调用connect方法,连接到服务器上. 3.将发送到服务器的IO流填充到IO对象里,比如BufferedReader/PrintWriter

Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）

转载请注明出处:http://blog.csdn.net/anxpp/article/details/51512200,谢谢! 本文会从传统的BIO到NIO再到AIO自浅至深介绍,并附上完整的代码讲解. 下面代码中会使用这样一个例子:客户端发送一段算式的字符串到服务器,服务器计算后返回结果到客户端. 代码的所有说明,都直接作为注释,嵌入到代码中,看代码时就能更容易理解,代码中会用到一个计算结果的工具类,见文章代码部分. 相关的基础知识文章推荐: Linux 网络 I/O 模型简介(图文) Jav

iOS网络编程笔记——Socket编程

一.什么是Socket通信: Socket是网络上的两个程序,通过一个双向的通信连接,实现数据的交换.这个双向连路的一端称为socket.socket通常用来实现客户方和服务方的连接.socket是TCP/IP协议的一个十分流行的编程接口.一个socket由一个IP地址和一个端口号唯一确定.TCP/IP协议的传输层又有两种协议:TCP(传输控制协议)和UDP(用户数据报协议).TCP是基于连接的,而UDP是无连接的:TCP对系统资源的要求较多,而UDP少:TCP保证数据的正确性而UDP可能丢包:

socket编程之三：socket网络编程中的常用函数

这节本来打算先给出常用函数介绍,再给两个代码实例,写着写着发现越来越长,决定把代码放在下一节. 本节内容持续更新...... 1 socket()函数 原型: int socket(int domain, int type, int protocol); 描述: 类似打开一个文件,返回一个socket描述符,唯一标识一个socket,后面相应的操作都是这用这个socket描述符. 参数: domain:协议族,常用的协议族有AF_INET.AF_INET6.AF_LOCAL.AF_ROUTE等:

Linux C Socket编程原理及简单实例

原文:http://www.cnblogs.com/xudong-bupt/archive/2013/12/29/3483059.html 部分转自:http://goodcandle.cnblogs.com/archive/2005/12/10/294652.aspx 1.   什么是TCP/IP.UDP? 2.   Socket在哪里呢? 3.   Socket是什么呢? 4.   有很多的框架,为什么还在从Socket开始? 5.   Linux C Socket简单示例 1.什么是TCP

Java网络编程基础（二）-- 基于TCP/IP的Socket编程

本节讲点: 客户端套接字:Socket:Socket的创建和使用方法,以及Socket选项和异常. 服务端套接字:ServerSocket:SeverSocket的创建和使用方法,以及ServerSocket选项 简单的Client/Server对话程序 支持多客户端的Client/Server服务响应程序 在学习JDK的网络编程之前先要了解一下网络基础知识和网络协议. TCP(传输控制协议)一种基于连接的通信协议.可靠传输 UDP(用户数据包协议)不稳定连接的通信协议 TCP和UDP的端口如下

Java网络编程-Nio 实例代码

IO NIO 区别请看 : http://blog.csdn.net/jiangtao_st/article/details/38041479 一.基于Nio的 Server ,过程略复杂,但是无疑这样的效率高:代码中得注释比较详细,请看注释说明 package com.zhuoxuan.net.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; imp

网络 基于UDP协议的socket编程

一.UDP协议        UDP协议的特点:用户数据包协议             1.UDP协议是无连接的.也就说在数据发送之前并不需要建立连接(当然,在发送数据结束的时候也就不存在链接的释放),因此减少了开销和数据发送之前的时延.             2.UDP使用尽最大努力的交付,但是不保证可靠性的交付,因此主机不需要维持复杂的链接状态表.(网上的的可靠性建立在应答的基础上,不提供可靠性交付,即不需要应答,因此不需要维护状态表)             3.UDP是面向报文.发送方

(转)Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）

原文出自:http://blog.csdn.net/anxpp/article/details/51512200 1.BIO编程 1.1.传统的BIO编程 网络编程的基本模型是C/S模型,即两个进程间的通信. 服务端提供IP和监听端口,客户端通过连接操作想服务端监听的地址发起连接请求,通过三次握手连接,如果连接成功建立,双方就可以通过套接字进行通信. 传统的同步阻塞模型开发中,ServerSocket负责绑定IP地址,启动监听端口:Socket负责发起连接操作.连接成功后,双方通过输入和输出流进