Java Socket与操作系统的关系

Socket与操作系统有什么关系呢？请细读下文

简介

TCP简介

TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793定义。在简化的计算机网络OSI模型中，它完成第四层传输层所指定的功能，用户数据报协议（UDP，下一篇博客会实现）是同一层内 另一个重要的传输协议。在因特网协议族（Internet protocol suite）中，TCP层是位于IP层之上，应用层之下的中间层。不同主机的应用层之间经常需要可靠的、像管道一样的连接，但是IP层不提供这样的流机制，而是提供不可靠的包交换。

应用层向TCP层发送用于网间传输的、用8位字节表示的数据流，然后TCP把数据流分区成适当长度的报文段（通常受该计算机连接的网络的数据链路层的最大传输单元（ MTU）的限制）。之后TCP把结果包传给IP层，由它来通过网络将包传送给接收端实体的TCP层。TCP为了保证不发生丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的包发回一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未收到确认，那么对应的数据包就被假设为已丢失将会被进行重传。TCP用一个校验和函数来检验数据是否有错误；在发送和接收时都要计算校验和。

JAVA Socket简介

所谓socket 通常也称作”套接字“，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过”套接字”向网络发出请求或者应答网络请求。

以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

重要的Socket API：

java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。

. Accept方法用于产生”阻塞”，直到接受到一个连接，并且返回一个客户端的Socket对象实例。”阻塞”是一个术语，它使程序运行暂时”停留”在这个地方，直到一个会话产生，然后程序继续；通常”阻塞”是由循环产生的。

. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。 
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。

注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

SocketImpl介绍

既然不管是Socket还是ServerSocket它们的工作都是通**过SocketImpl类及其子类完成的，那么当然要介绍啦。

抽象类 SocketImpl 是实际实现套接字的所有类的通用超类。创建客户端和服务器套接字都可以使用它。

具体JDK见： 
http://www.javaweb.cc/help/JavaAPI1.6/index.html?java/nio/ReadOnlyBufferException.html

由于它是超类具体代码实现还是见下面的Socket

TCP 编程‘

构造ServerSocket

具体API见：http://www.javaweb.cc/help/JavaAPI1.6/index.html?java/nio/ReadOnlyBufferException.html

构造方法：

ServerSocket() ~创建非绑定服务器套接字。

ServerSocket(int port) ~创建绑定到特定端口的服务器套接字。

ServerSocket(int port, int backlog) ~利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。

ServerSocket(int port, int backlog, InetAddress bindAddr) ~使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。

1.1 绑定端口

除了第一个不带参数的构造方法以外, 其他构造方法都会使服务器与特定端口绑定, 该端口有参数 port 指定. 例如, 以下代码创建了一个与 80 端口绑定的服务器:

Java代码  

  1. ServerSocket serverSocket = new ServerSocket(80);  

 如果运行时无法绑定到 80 端口, 以上代码会抛出 IOException, 更确切地说, 是抛出 BindException, 它是 IOException 的子类. BindException 一般是由以下原因造成的:

  1. 端口已经被其他服务器进程占用;
  2. 在某些操作系统中, 如果没有以超级用户的身份来运行服务器程序, 那么操作系统不允许服务器绑定到 1-1023 之间的端口.

如果把参数 port 设为 0, 表示由操作系统来为服务器分配一个任意可用的端口. 有操作系统分配的端口也称为匿名端口. 对于多数服务器, 会使用明确的端口, 而不会使用匿名端口, 因为客户程序需要事先知道服务器的端口, 才能方便地访问服务器.

1.2 设定客户连接请求队列的长度

 

当服务器进程运行时, 可能会同时监听到多个客户的连接请求. 例如, 每当一个客户进程执行以下代码:

Java代码  

  1. Socket socket = new Socket("www.javathinker.org", 80);   

 就意味着在远程 www.javathinker.org 主机的 80 端口上, 监听到了一个客户的连接请求. 管理客户连接请求的任务是由操作系统来完成的. 操作系统把这些连接请求存储在一个先进先出的队列中. 许多操作系统限定了队列的最大长度, 一般为 50 . 当队列中的连接请求达到了队列的最大容量时, 服务器进程所在的主机会拒绝新的连接请求. 只有当服务器进程通过 ServerSocket 的 accept() 方法从队列中取出连接请求, 使队列腾出空位时, 队列才能继续加入新的连接请求.

对于客户进程, 如果它发出的连接请求被加入到服务器的请求连接队列中, 就意味着客户与服务器的连接建立成功, 客户进程从 Socket 构造方法中正常返回. 如果客户进程发出的连接请求被服务器拒绝, Socket 构造方法就会抛出 ConnectionException.

Tips: 创建绑定端口的服务器进程后, 当客户进程的 Socket构造方法返回成功, 表示客户进程的连接请求被加入到服务器进程的请求连接队列中. 虽然客户端成功返回 Socket对象, 但是还没跟服务器进程形成一条通信线路. 必须在服务器进程通过 ServerSocket 的 accept() 方法从请求连接队列中取出连接请求, 并返回一个Socket 对象后, 服务器进程这个Socket 对象才与客户端的 Socket 对象形成一条通信线路.

ServerSocket 构造方法的 backlog 参数用来显式设置连接请求队列的长度, 它将覆盖操作系统限定的队列的最大长度. 值得注意的是, 在以下几种情况中, 仍然会采用操作系统限定的队列的最大长度:

  1. backlog 参数的值大于操作系统限定的队列的最大长度;
  2. backlog 参数的值小于或等于0;
  3. 在ServerSocket 构造方法中没有设置 backlog 参数.

    以下的 Client.java 和 Server.java 用来演示服务器的连接请求队列的特性. 
    Client.java

Java代码  

  1. import java.net.Socket;  
  2. public class Client {  
  3.  public static void main(String[] args) throws Exception{  
  4.   final int length = 100;  
  5.   String host = "localhost";  
  6.   int port = 1122;  
  7.   Socket[] socket = new Socket[length];  
  8.   for(int i = 0;i<length;i++){  
  9.    socket[i] = new Socket(host,port);  
  10.    System.out.println("第"+(i+1)+"次连接成功！");  
  11.   }  
  12.   Thread.sleep(3000);  
  13.   for(int i=0;i<length;i++){  
  14.    socket[i].close();  
  15.   }  
  16.  }  
  17. }  

 Server.java

Java代码  

  1. import java.io.IOException;  
  2. import java.net.ServerSocket;  
  3. import java.net.Socket;  
  4. public class Server {  
  5.  private int port = 1122;  
  6.  private ServerSocket serverSocket;  
  7.   
  8.  public Server() throws Exception{  
  9.   serverSocket = new ServerSocket(port,3);  
  10.   System.out.println("服务器启动!");  
  11.  }  
  12.  public void service(){  
  13.   while(true){  
  14.    Socket socket = null;  
  15.    try {  
  16.     socket = serverSocket.accept();  
  17.     System.out.println("New connection accepted "+  
  18.       socket.getInetAddress()+":"+socket.getPort());  
  19.    } catch (IOException e) {  
  20.     e.printStackTrace();  
  21.    }finally{  
  22.     if(socket!=null){  
  23.      try {  
  24.       socket.close();  
  25.      } catch (IOException e) {  
  26.       e.printStackTrace();  
  27.      }  
  28.     }  
  29.    }  
  30.   }  
  31.  }  
  32.   
  33.  public static void main(String[] args) throws Exception{  
  34.   Server server = new Server();  
  35.   Thread.sleep(60000*10);  
  36.   server.service();  
  37.  }  
  38. }   

 ⑴ 在Server 中只创建一个 ServerSocket 对象, 在构造方法中指定监听的端口为1122 和 连接请求队列的长度为 3 . 构造 Server 对象后, Server 程序睡眠 10 分钟, 并且在 Server 中不执行 serverSocket.accept() 方法. 这意味着队列中的连接请求永远不会被取出. 运行Server 程序和 Client 程序后, Client程序的打印结果如下: 

第 1 次连接成功 
第 2 次连接成功 
第 3 次连接成功 
Exception in thread “main” java.net.ConnectException: Connection refused: connect 
……………. 
从以上打印的结果可以看出, Client 与 Server 在成功地建立了3 个连接后, 就无法再创建其余的连接了, 因为服务器的队已经满了.

⑵ 在Server中构造一个跟 ⑴ 相同的 ServerSocket对象, Server程序不睡眠, 在一个 while 循环中不断执行 serverSocket.accept()方法, 该方法从队列中取出连接请求, 使得队列能及时腾出空位, 以容纳新的连接请求. Client 程序的打印结果如下: 
第 1 次连接成功 
第 2 次连接成功 
第 3 次连接成功 
……….. 
第 100 次连接成功 
从以上打印结果可以看出, 此时 Client 能顺利与 Server 建立 100 次连接.(每次while的循环要够快才行, 如果太慢, 从队列取连接请求的速度比放连接请求的速度慢的话, 不一定都能成功连接)

1.3 设定绑定的IP 地址

如果主机只有一个IP 地址, 那么默认情况下, 服务器程序就与该IP 地址绑定. ServerSocket 的第 4 个构造方法 ServerSocket(int port, int backlog, InetAddress bingAddr) 有一个 bindAddr 参数, 它显式指定服务器要绑定的IP 地址, 该构造方法适用于具有多个IP 地址的主机. 假定一个主机有两个网卡, 一个网卡用于连接到 Internet, IP为 222.67.5.94, 还有一个网卡用于连接到本地局域网, IP 地址为 192.168.3.4. 如果服务器仅仅被本地局域网中的客户访问, 那么可以按如下方式创建 ServerSocket:

ServerSocket serverSocket = new ServerSocket(8000, 10, InetAddress.getByName(“192.168.3.4”));

1.4 默认构造方法的作用

ServerSocket 有一个不带参数的默认构造方法. 通过该方法创建的 ServerSocket 不与任何端口绑定, 接下来还需要通过 bind() 方法与特定端口绑定.

这个默认构造方法的用途是, 允许服务器在绑定到特定端口之前, 先设置ServerSocket 的一些选项. 因为一旦服务器与特定端口绑定, 有些选项就不能再改变了.比如：SO_REUSEADDR 选项

 

在以下代码中, 先把 ServerSocket 的 SO_REUSEADDR 选项设为 true, 然后再把它与 8000 端口绑定:

Java代码  

  1. ServerSocket serverSocket = new ServerSocket();  
  2. serverSocket.setReuseAddress(true); //设置 ServerSocket 的选项  
  3. serverSocket.bind(new InetSocketAddress(8000));  //与8000端口绑定  

 如果把以上程序代码改为:

Java代码  

  1. ServerSocket serverSocket = new ServerSocket(8000);  
  2.  serverSocket.setReuseAddress(true);//设置 ServerSocket 的选项  

那么 serverSocket.setReuseAddress(true) 方法就不起任何作用了, 因为 SO_REUSEADDR 选项必须在服务器绑定端口之前设置才有效.

多线程示例

客户端：

Java代码  

  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import java.io.OutputStream;  
  6. import java.io.PrintWriter;  
  7. import java.net.Socket;  
  8. import java.net.UnknownHostException;  
  9.   
  10. /* 
  11.  * 客户端 
  12.  */  
  13. public class Client {  
  14.     public static void main(String[] args) {  
  15.         try {  
  16.             //1.创建客户端Socket，指定服务器地址和端口  
  17.             Socket socket=new Socket("localhost", 8888);  
  18.             //2.获取输出流，向服务器端发送信息  
  19.             OutputStream os=socket.getOutputStream();//字节输出流  
  20.             PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流  
  21.             pw.write("用户名：whf;密码：789");  
  22.             pw.flush();  
  23.             socket.shutdownOutput();//关闭输出流  
  24.             //3.获取输入流，并读取服务器端的响应信息  
  25.             InputStream is=socket.getInputStream();  
  26.             BufferedReader br=new BufferedReader(new InputStreamReader(is));  
  27.             String info=null;  
  28.             while((info=br.readLine())!=null){  
  29.                 System.out.println("我是客户端，服务器说："+info);  
  30.             }  
  31.             //4.关闭资源  
  32.             br.close();  
  33.             is.close();  
  34.             pw.close();  
  35.             os.close();  
  36.             socket.close();  
  37.         } catch (UnknownHostException e) {  
  38.             e.printStackTrace();  
  39.         } catch (IOException e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.     }  
  43. }  

  服务端：

Java代码  

  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import java.io.OutputStream;  
  6. import java.io.PrintWriter;  
  7. import java.net.InetAddress;  
  8. import java.net.ServerSocket;  
  9. import java.net.Socket;  
  10.   
  11. /* 
  12.  * 基于TCP协议的Socket通信，实现用户登陆 
  13.  * 服务器端 
  14.  */  
  15. public class Server {  
  16.     public static void main(String[] args) {  
  17.         try {  
  18.             //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口  
  19.             ServerSocket serverSocket=new ServerSocket(8888);  
  20.             Socket socket=null;  
  21.             //记录客户端的数量  
  22.             int count=0;  
  23.             System.out.println("***服务器即将启动，等待客户端的连接***");  
  24.             //循环监听等待客户端的连接  
  25.             while(true){  
  26.                 //调用accept()方法开始监听，等待客户端的连接  
  27.                 socket=serverSocket.accept();  
  28.                 //创建一个新的线程  
  29.                 ServerThread serverThread=new ServerThread(socket);  
  30.                 //启动线程  
  31.                 serverThread.start();  
  32.   
  33.                 count++;//统计客户端的数量  
  34.                 System.out.println("客户端的数量："+count);  
  35.                 InetAddress address=socket.getInetAddress();  
  36.                 System.out.println("当前客户端的IP："+address.getHostAddress());  
  37.             }  
  38.         } catch (IOException e) {  
  39.             e.printStackTrace();  
  40.         }  
  41.     }  
  42. }  

 服务器处理类：

Java代码  

  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import java.io.OutputStream;  
  6. import java.io.PrintWriter;  
  7. import java.net.Socket;  
  8.   
  9. /* 
  10.  * 服务器线程处理类 
  11.  */  
  12. public class ServerThread extends Thread {  
  13.     // 和本线程相关的Socket  
  14.     Socket socket = null;  
  15.   
  16.     public ServerThread(Socket socket) {  
  17.         this.socket = socket;  
  18.     }  
  19.   
  20.     //线程执行的操作，响应客户端的请求  
  21.     public void run(){  
  22.         InputStream is=null;  
  23.         InputStreamReader isr=null;  
  24.         BufferedReader br=null;  
  25.         OutputStream os=null;  
  26.         PrintWriter pw=null;  
  27.         try {  
  28.             //获取输入流，并读取客户端信息  
  29.             is = socket.getInputStream();  
  30.             isr = new InputStreamReader(is);  
  31.             br = new BufferedReader(isr);  
  32.             String info=null;  
  33.             while((info=br.readLine())!=null){//循环读取客户端的信息  
  34.                 System.out.println("我是服务器，客户端说："+info);  
  35.             }  
  36.             socket.shutdownInput();//关闭输入流  
  37.             //获取输出流，响应客户端的请求  
  38.             os = socket.getOutputStream();  
  39.             pw = new PrintWriter(os);  
  40.             pw.write("欢迎您！");  
  41.             pw.flush();//调用flush()方法将缓冲输出  
  42.         } catch (IOException e) {  
  43.             // TODO Auto-generated catch block  
  44.             e.printStackTrace();  
  45.         }finally{  
  46.             //关闭资源  
  47.             try {  
  48.                 if(pw!=null)  
  49.                     pw.close();  
  50.                 if(os!=null)  
  51.                     os.close();  
  52.                 if(br!=null)  
  53.                     br.close();  
  54.                 if(isr!=null)  
  55.                     isr.close();  
  56.                 if(is!=null)  
  57.                     is.close();  
  58.                 if(socket!=null)  
  59.                     socket.close();  
  60.             } catch (IOException e) {  
  61.                 e.printStackTrace();  
  62.             }  
  63.         }  
  64.     }  
  65. }  

 附：TCP vs UDP

TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂，我们这里只做简单、形象的介绍，你只要做到能够理解这个过程即可。我们来看看这三次对话的简单过程：主机A向主机B发出连接请求数据包：“我想给你发数据，可以吗？”，这是第一次对话；主机B向主机A发送同意连接和要求同步（同步就是两台主机一个在发送，一个在接收，协调工作）的数据包：“可以，你什么时候发？”，这是第二次对话；主机A再发出一个数据包确认主机B的要求同步：“我现在就发，你接着吧！”，这是第三次对话。三次“对话”的目的是使数据包的发送和接收同步，经过三次“对话”之后，主机A才向主机B正式发送数据。 

 

UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去！ 

  UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境。比如，我们经常使用“ping”命令来测试两台主机之间TCP/IP通信是否正常，其实“ping”命令的原理就是向对方主机发送UDP数据包，然后对方主机确认收到数据包，如果数据包是否到达的消息及时反馈回来，那么网络就是通的。例如，在默认状态下，一次“ping”操作发送4个数据包（如图2所示）。大家可以看到，发送的数据包数量是4包，收到的也是4包（因为对方主机收到后会发回一个确认收到的数据包）。这充分说明了UDP协议是面向非连接的协议，没有建立连接的过程。正因为UDP协议没有连接的过程，所以它的通信效果高；但也正因为如此，它的可靠性不如TCP协议高。QQ就使用UDP发消息，因此有时会出现收不到消息的情况。 

 

tcp协议和udp协议的差别 

TCP UDP 

是否连接 面向连接 面向非连接 

传输可靠性 可靠 不可靠 

应用场合 传输大量数据 少量数据 

 

速度 慢 快



原文链接：[http://wely.iteye.com/blog/2324635]

时间： 2024-10-27 02:00:31

Java Socket与操作系统的关系的相关文章

Java socket编程入门

编程 第一章:学习提示 我适合学习这份教程吗 Socket提供了两台计算机之间进行通讯的机制,在James Gosling注意Java语言之前就已经很闻名了.Java语言使你更简单有效的使用Socket开发而无需了解操作系统的底层机制.大部分讨论Java编码的书籍都没有涉及这一主题,或者是只是"点到为止",留给读者大量的想象空间.这份教程就是让你了解在你的Java代码中如何更有效的使用Socket所需的知识.包含以下内容: •什么是Socket •它位于你的应用程序的哪些地方 •能正常

Java socket编程入门[1]

编程 第一章:学习提示 我适合学习这份教程吗 Socket提供了两台计算机之间进行通讯的机制,在James Gosling注意Java语言之前就已经很闻名了.Java语言使你更简单有效的使用Socket开发而无需了解操作系统的底层机制.大部分讨论Java编码的书籍都没有涉及这一主题,或者是只是"点到为止",留给读者大量的想象空间.这份教程就是让你了解在你的Java代码中如何更有效的使用Socket所需的知识.包含以下内容:•什么是Socket•它位于你的应用程序的哪些地方•能正常运行的

用Java Socket开发支持上千个并发的小型服务器（上）

Java Socket 套接字(socket)为两台计算机之间的通信提供了一种机制,在JamesGosling注意到Java语言之前,套接字就早已赫赫有名.该语言只是让您不必了解底层操作系统的细节就能有效地使用套接字. 1客户机/服务器模型 在饭店里,菜单上各种具有异国情调的食品映入你的眼帘,于是你要了一份pizza.几分钟后,你用力咀嚼浇着融化的乳酪和其他你喜欢的配料的热pizza.你不知道,也不想知道:侍者从那里弄来了pizza,在制作过程中加进了什么,以及配料是如何获得的. 上例中包含的实

JAVA Socket超时浅析（转）

  套接字或插座(socket)是一种软件形式的抽象,用于表达两台机器间一个连接的"终端".针对一个特定的连接,每台机器上都有一个"套接字",可以想象它们之间有一条虚拟的"线缆".JAVA有两个基于数据流的套接字类:ServerSocket,服务器用它"侦听"进入的连接:Socket,客户端用它初始一次连接.侦听套接字只能接收新的连接请求,不能接收实际的数据包.   套接字是基于TCP/IP实现的,它是用来提供一个访问TCP的

java socket 的参数选项解读(转)

  java socket中有很多参数可以选择,这篇博客的目的是沉淀出这些参数的语义和用法,供自己以后查阅. 1.java socket参数选项总览       在JDK1.6中有如下参数选项: 1 public final static int TCP_NODELAY = 0x0001; 2 3 public final static int SO_BINDADDR = 0x000F; 4 5 public final static int SO_REUSEADDR = 0x04; 6 7 p

java socket多线程的时间问题

问题描述 java socket多线程的时间问题 各位大神你们好, 我正在用java写一个接收服务器数据并进行统计的程序, 我用的是多线程socket. 该程序要求能够每秒钟接收几千条数据, 数据中包含value和timestamp以及其他字段. 每个数据通过单独的连接发送, 接收之后统计每秒的钟数据的最大值与平均值(指的是数据中所含有的"value"字段的值), 并将其存储到本地. 但是使用多线程时我有个疑问, 就是怎么判断是否到了1秒. 如果使用本地时钟计算肯定会与服务器有出入,

Java Socket聊天室编程(一)之利用socket实现聊天之消息推送_java

相关阅读:Java Socket聊天室编程(二)之利用socket实现单聊聊天室 网上已经有很多利用socket实现聊天的例子了,但是我看过很多,多多少有一些问题存在. 这里我将实现一个比较完整的聊天例子,并解释其中的逻辑. 由于socket这一块比较大,所以我将分出几篇来写一个比较完整的socket例子. 这里我们先来实现一个最简单的,服务器与客户端通讯,实现消息推送的功能. 目的:服务器与客户端建立连接,客户端可以向服务器发送消息,服务器可以向客户端推送消息. 1,使用java建立socke

Java socket字节流传输示例解析_java

本文为大家分享了Java socket字节流传输示例,供大家参考,具体内容如下 服务端server端:  package com.yuan.socket; import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * Created by YUAN on 2016-09-17. */ public class TalkServer4Byte { private ServerSocket server;

Java Socket实现客户端服务画面同步，报错

问题描述 Java Socket实现客户端服务画面同步,报错 java.net.ConnectException: Connection refused: connect at java.net.DualStackPlainSocketImpl.connect0(Native Method) at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79) at java.net.Abstra