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代码  
    
ServerSocket serverSocket = new ServerSocket(80);

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

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

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

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

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

    Java代码  
    
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 参数用来显式设置连接请求队列的长度, 它将覆盖操作系统限定的队列的最大长度. 值得注意的是, 在以下几种情况中, 仍然会采用操作系统限定的队列的最大长度:

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

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

    Java代码  
    
  
import java.net.Socket;  
public class Client {  
 public static void main(String[] args) throws Exception{  
  final int length = 100;  
  String host = "localhost";  
  int port = 1122;  
  Socket[] socket = new Socket[length];  
  for(int i = 0;i<length;i++){  
   socket[i] = new Socket(host,port);  
   System.out.println("第"+(i+1)+"次连接成功！");  
  }  
  Thread.sleep(3000);  
  for(int i=0;i<length;i++){  
   socket[i].close();  
  }  
 }  
}  

Server.java

    Java代码  
    
  
import java.io.IOException;  
import java.net.ServerSocket;  
import java.net.Socket;  
public class Server {  
 private int port = 1122;  
 private ServerSocket serverSocket;  
  
 public Server() throws Exception{  
  serverSocket = new ServerSocket(port,3);  
  System.out.println("服务器启动!");  
 }  
 public void service(){  
  while(true){  
   Socket socket = null;  
   try {  
    socket = serverSocket.accept();  
    System.out.println("New connection accepted "+  
      socket.getInetAddress()+":"+socket.getPort());  
   } catch (IOException e) {  
    e.printStackTrace();  
   }finally{  
    if(socket!=null){  
     try {  
      socket.close();  
     } catch (IOException e) {  
      e.printStackTrace();  
     }  
    }  
   }  
  }  
 }  
  
 public static void main(String[] args) throws Exception{  
  Server server = new Server();  
  Thread.sleep(60000*10);  
  server.service();  
 }  
}   

⑴ 在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代码  
    
  
ServerSocket serverSocket = new ServerSocket();  
serverSocket.setReuseAddress(true); //设置 ServerSocket 的选项  
serverSocket.bind(new InetSocketAddress(8000));  //与8000端口绑定  

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

    Java代码  
    
  
ServerSocket serverSocket = new ServerSocket(8000);  
 serverSocket.setReuseAddress(true);//设置 ServerSocket 的选项  

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

多线程示例

客户端：

    Java代码  
    
  
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.io.PrintWriter;  
import java.net.Socket;  
import java.net.UnknownHostException;  
  
/* 
 * 客户端 
 */  
public class Client {  
    public static void main(String[] args) {  
        try {  
            //1.创建客户端Socket，指定服务器地址和端口  
            Socket socket=new Socket("localhost", 8888);  
            //2.获取输出流，向服务器端发送信息  
            OutputStream os=socket.getOutputStream();//字节输出流  
            PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流  
            pw.write("用户名：whf;密码：789");  
            pw.flush();  
            socket.shutdownOutput();//关闭输出流  
            //3.获取输入流，并读取服务器端的响应信息  
            InputStream is=socket.getInputStream();  
            BufferedReader br=new BufferedReader(new InputStreamReader(is));  
            String info=null;  
            while((info=br.readLine())!=null){  
                System.out.println("我是客户端，服务器说："+info);  
            }  
            //4.关闭资源  
            br.close();  
            is.close();  
            pw.close();  
            os.close();  
            socket.close();  
        } catch (UnknownHostException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

服务端：

    Java代码  
    
  
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.io.PrintWriter;  
import java.net.InetAddress;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
/* 
 * 基于TCP协议的Socket通信，实现用户登陆 
 * 服务器端 
 */  
public class Server {  
    public static void main(String[] args) {  
        try {  
            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口  
            ServerSocket serverSocket=new ServerSocket(8888);  
            Socket socket=null;  
            //记录客户端的数量  
            int count=0;  
            System.out.println("***服务器即将启动，等待客户端的连接***");  
            //循环监听等待客户端的连接  
            while(true){  
                //调用accept()方法开始监听，等待客户端的连接  
                socket=serverSocket.accept();  
                //创建一个新的线程  
                ServerThread serverThread=new ServerThread(socket);  
                //启动线程  
                serverThread.start();  
  
                count++;//统计客户端的数量  
                System.out.println("客户端的数量："+count);  
                InetAddress address=socket.getInetAddress();  
                System.out.println("当前客户端的IP："+address.getHostAddress());  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

服务器处理类：

    Java代码  
    
  
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.io.PrintWriter;  
import java.net.Socket;  
  
/* 
 * 服务器线程处理类 
 */  
public class ServerThread extends Thread {  
    // 和本线程相关的Socket  
    Socket socket = null;  
  
    public ServerThread(Socket socket) {  
        this.socket = socket;  
    }  
  
    //线程执行的操作，响应客户端的请求  
    public void run(){  
        InputStream is=null;  
        InputStreamReader isr=null;  
        BufferedReader br=null;  
        OutputStream os=null;  
        PrintWriter pw=null;  
        try {  
            //获取输入流，并读取客户端信息  
            is = socket.getInputStream();  
            isr = new InputStreamReader(is);  
            br = new BufferedReader(isr);  
            String info=null;  
            while((info=br.readLine())!=null){//循环读取客户端的信息  
                System.out.println("我是服务器，客户端说："+info);  
            }  
            socket.shutdownInput();//关闭输入流  
            //获取输出流，响应客户端的请求  
            os = socket.getOutputStream();  
            pw = new PrintWriter(os);  
            pw.write("欢迎您！");  
            pw.flush();//调用flush()方法将缓冲输出  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }finally{  
            //关闭资源  
            try {  
                if(pw!=null)  
                    pw.close();  
                if(os!=null)  
                    os.close();  
                if(br!=null)  
                    br.close();  
                if(isr!=null)  
                    isr.close();  
                if(is!=null)  
                    is.close();  
                if(socket!=null)  
                    socket.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

附：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]

Java Socket与操作系统的关系

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

简介

TCP简介

JAVA Socket简介

SocketImpl介绍

TCP 编程‘

构造ServerSocket

1.1 绑定端口

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

1.3 设定绑定的IP 地址

1.4 默认构造方法的作用

多线程示例

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java Socket与操作系统的关系

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

简介

TCP简介

JAVA Socket简介

SocketImpl介绍

TCP 编程‘

构造ServerSocket

1.1 绑定端口

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

1.3 设定绑定的IP 地址

1.4 默认构造方法的作用

多线程示例

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像