Socket底层实现

首先必须明确:TCP/IP模型中有四层结构:
     应用层(Application Layer)、传输层(Transport Layer)、网络层(Internet Layer  )、链路层(LinkLayer)
 其中Ip协议(InternetProtocol)是位于网络层的,TCP协议时位于传输层的。通过Ip协议可以使可以使两台计算机使用同一种语言,从而允许Internet上连接不同类型的计算机和不同操作系统的网络。Ip协议只保证计算机能够接收和发送分组数据。当计算机要和远程的计算机建立连接时,TCP协议会让他们建立连接:用于发送和接收数据的虚拟电路。



在JAVA中,我们用 ServerSocket、Socket类创建一个套接字连接,从套接字得到的结果是一个InputStream以及OutputStream对象,以便将连接作为一个IO流对象对待。通过IO流可以从流中读取数据或者写数据到流中,读写IO流会有异常IOException产生。

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

  套接字是基于TCP/IP实现的,它是用来提供一个访问TCP的服务接口,或者说套接字socket是TCP的应用编程接口API,通过应用层就可以访问TCP提供的服务。

在JAVA中,我们用ServerSocket、Socket类创建一个套接字连接,从套接字得到的结果是一个InputStream以及OutputStream对象,以便将连接作为一个IO流对象对待。通过IO流可以从流中读取数据或者写数据到流中,读写IO流会有异常IOException产生。

 套接字底层是基于TCP的,所以socket的超时和TCP超时是相同的。下面先讨论套接字读写缓冲区,接着讨论连接建立超时、读写超时以及JAVA套接字编程的嵌套异常捕获和一个超时例子程序的抓包示例。

1socket读写缓冲区

 一旦创建了一个套接字实例,操作系统就会为其分配缓冲区以存放接收和要发送的数据。

 

 

 JAVA可以设置读写缓冲区的大小-setReceiveBufferSize(int size),setSendBufferSize(int size)。

  向输出流写数据并不意味着数据实际上已经被发送,它们只是被复制到了发送缓冲区队列SendQ,就是在Socket的OutputStream上调用flush()方法,也不能保证数据能够立即发送到网络。真正的数据发送是由操作系统的TCP协议栈模块从缓冲区中取数据发送到网络来完成的。

 当有数据从网络来到时,TCP协议栈模块接收数据并放入接收缓冲区队列RecvQ,输入流InputStream通过read方法从RecvQ中取出数据。

2 socket连接建立超时

 socket连接建立是基于TCP的连接建立过程。TCP的连接需要通过3次握手报文来完成,开始建立TCP连接时需要发送同步SYN报文,然后等待确认报文SYN+ACK,最后再发送确认报文ACK。TCP连接的关闭通过4次挥手来完成,主动关闭TCP连接的一方发送FIN报文,等待对方的确认报文;被动关闭的一方也发送FIN报文,然等待确认报文。


  正在等待TCP连接请求的一端有一个固定长度的连接队列,该队列中的连接已经被TCP接受(即三次握手已经完成),但还没有被应用层所接受TCP接受一个连接是将其放入这个连接队列,而应用层接受连接是将其从该队列中移出。应用层可以通过设置backlog变量来指明该连接队列的最大长度,即已被TCP接受而等待应用层接受的最大连接数。

 当一个连接请求SYN到达时,TCP确定是否接受这个连接。如果队列中还有空间,TCP模块将对SYN进行确认并完成连接的建立。但应用层只有在三次握手中的第三个报文收到后才会知道这个新连接。如果队列没有空间,TCP将不理会收到的SYN。

 如果应用层不能及时接受已被TCP接受的连接,这些连接可能占满整个连接队列,新的连接请求可能不被响应而会超时。如果一个连接请求SYN发送后,一段时间后没有收到确认SYN+ACK,TCP会重传这个连接请求SYN两次,每次重传的时间间隔加倍,在规定的时间内仍没有收到SYN+ACK,TCP将放弃这个连接请求,连接建立就超时了。

  JAVASocket连接建立超时和TCP是相同的,如果TCP建立连接时三次握手超时,那么导致Socket连接建立也就超时了。可以设置Socket连接建立的超时时间-

connect(SocketAddress endpoint, inttimeout)

如果在timeout内,连接没有建立成功,在TimeoutException异常被抛出。如果timeout的值小于三次握手的时间,那么Socket连接永远也不会建立。

 不同的应用层有不同的连接建立过程,Socket的连接建立和TCP一样-仅仅需要三次握手就完成连接,但有些应用程序需要交互很多信息后才能成功建立连接,比如Telnet协议,在TCP三次握手完成后,需要进行选项协商之后,Telnet连接才建立完成。

3 socket读超时

 如果输入缓冲队列RecvQ中没有数据,read操作会一直阻塞而挂起线程,直到有新的数据到来或者有异常产生。调用setSoTimeout(inttimeout)可以设置超时时间,如果到了超时时间仍没有数据,read会抛出一个SocketTimeoutException,程序需要捕获这个异常,但是当前的socket连接仍然是有效的。

 如果对方进程崩溃、对方机器突然重启、网络断开,本端的read会一直阻塞下去(由前面可知:双方要关闭连接需要四次挥手.对方机重启或断开只是对方机的TCP连接关闭,本端的TCP连接还没关闭所以本端机会一直阻塞),这时设置超时时间是非常重要的,否则调用read的线程会一直挂起。

 TCP模块把接收到的数据放入RecvQ中,直到应用层调用输入流的read方法来读取。如果RecvQ队列被填满了,这时TCP会根据滑动窗口机制通知对方不要继续发送数据,本端停止接收从对端发送来的数据,直到接收者应用程序调用输入流的read方法后腾出了空间。

4 socket写超时

 socket的写超时是基于TCP的超时重传。超时重传是TCP保证数据可靠性传输的一个重要机制,其原理是在发送一个数据报文后就开启一个计时器,在一定时间内如果没有得到发送报文的确认ACK,那么就重新发送报文。如果重新发送多次之后,仍没有确认报文,就发送一个复位报文RST,然后关闭TCP连接。首次数据报文发送与复位报文传输之间的时间差大约为9分钟,也就是说如果9分钟内没有得到确认报文,就关闭连接。但是这个值是根据不同的TCP协议栈实现而不同。

 如果发送端调用write持续地写出数据,直到SendQ队列被填满。如果在SendQ队列已满时调用write方法,则write将被阻塞,直到SendQ有新的空闲空间为止,也就是说直到一些字节传输到了接收者套接字的RecvQ中。如果此时RecvQ队列也已经被填满,所有操作都将停止,直到接收端调用read方法将一些字节传输到应用程序。

  当Socket的write发送数据时,如果网线断开、对端进程崩溃或者对端机器重启动,由前面可知:双方要关闭连接需要四次挥手.对端进程崩溃或者对端机器重启动只是对方机的TCP连接关闭,本端的TCP连接还没关闭所以本端机会一直阻塞TCP模块会重传数据,最后超时而关闭连接。下次如再调用write会导致一个异常而退出。

 Socket写超时是基于TCP协议栈的超时重传机制,一般不需要设置write的超时时间,也没有提供这种方法。

5 双重嵌套异常捕获

  如果ServerSocket、Socket构造失败,只需要仅仅捕获这个构造失败异常而不需要调用套接字的close方法来释放资源(必须保证构造失败后不会留下任何需要清除的资源),因为这时套接字内部资源没有被成功分配。如果构造成功,必须进入一个tryfinally语句块里调用close释放套接字。请参照下面例子程序。

 

import java.net.*;
import java.io.*;
public class SocketClientTest
{
  public static final int PORT = 8088;
  public static void main( String[] args ) throwsException
  {
    InetAddressaddr = InetAddress.getByName( "127.0.0.1" );
    Socketsocket = new Socket();
    try
    {
     socket.connect( new InetSocketAddress( addr, PORT ), 30000 );
     socket.setSendBufferSize(100);
     
     BufferedWriter out = new BufferedWriter( new OutputStreamWriter(socket.getOutputStream() ) );
     int i = 0;
     
     while( true )
     {
       System.out.println( "client sent --- hello *** " + i++ );
       out.write( "client sent --- hello *** " + i );
       out.flush();
       
       Thread.sleep( 1000 );
     }
    }
   finally
    {
     socket.close();
    }
  }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServerTest
{
  public static final int PORT = 8088;
  public static final int BACKLOG = 2;
  public static void main( String[] args ) throwsIOException
  {
    ServerSocketserver = new ServerSocket( PORT, BACKLOG );
   System.out.println("started: " + server);
    try
    {
     Socket socket = server.accept();
     try
     {
       BufferedReader in = new BufferedReader( new InputStreamReader(socket.getInputStream() ) );
       String info = null;
       
       while( ( info = in.readLine() ) != null )
       {
         System.out.println( info );
       }
     }
     finally
     {
       socket.close();
     }
    }
   finally
    {
     server.close();
    }
  }
}

执行上面的程序,在程序运行一会儿之后,断开client和server之间的网络连接,在机器上输出如下:

 

Server上的输出:

Echoing:client sent-----hello0

Echoing:client sent-----hello1

Echoing:client sent-----hello2

Echoing:client sent-----hello3

Echoing:client sent-----hello4

Echoing:client sent-----hello5

Echoing:client sent-----hello6

 

---->>断开了网络连接之后没有数据输出

 

Client上的输出:

socket default timeout= 0

socket =Socket[addr=/10.15.9.99,port=8088,localport=4691]

begin toread

client sent --- hello*** 0

client sent --- hello*** 1

client sent --- hello*** 2

client sent --- hello*** 3

client sent --- hello*** 4

client sent --- hello*** 5

client sent --- hello*** 6

client sent --- hello*** 7

client sent --- hello*** 8  

client sent --- hello*** 9

client sent --- hello*** 10

 

 ---->> 断开网络连接后客户端进程挂起

 

java.net.SocketException : Connection reset by peer: socket write error

    atjava.net.SocketOutputStream.socketWrite0( Native Method )

    atjava.net.SocketOutputStream.socketWrite( SocketOutputStream.java:92 )

    atjava.net.SocketOutputStream.write( SocketOutputStream.java:136 )

    atsun.nio.cs.StreamEncoder.writeBytes( StreamEncoder.java:202 )

    atsun.nio.cs.StreamEncoder.implFlushBuffer( StreamEncoder.java:272 )

    atsun.nio.cs.StreamEncoder.implFlush( StreamEncoder.java:276 )

    atsun.nio.cs.StreamEncoder.flush( StreamEncoder.java:122 )

    atjava.io.OutputStreamWriter.flush( OutputStreamWriter.java:212 )

    atjava.io.BufferedWriter.flush( BufferedWriter.java:236 )

    atcom.xtera.view.SocketClientTest.main( SocketClientTest.java:99 )

 

 当hello6被发送到server端后,网络连接被断开,这时server端不能接收任何数据而挂起。client端仍然继续发送数据,实际上hello7、hello8、hello9、hello10都被复制到SendQ队列中,write方法立即返回。当client的SendQ队列被填满之后,write方法就被阻塞。TCP模块在发送报文hello7之后,没有收到确认而超时重传,再重传几次之后关闭了TCP连接,同时导致被阻塞的write方法异常返回。

 通过抓包工具,我们可以看到超时重传的报文。

 

 

 

 

 

 

 

 

 

下面是规范代码实例:(服务端和客户端实现双向(可通过键盘输入)交互通信)

public class JabberClient {
 

    public static void main(String[] args)
        throws IOException {
       // Passingnull to getByName() produces the
       // special"Local Loopback" IP address, for
       // testingon one machine w/o a network:
       InetAddressaddr =
        InetAddress.getByName("127.0.0.1");
       //Alternatively, you can use
       // theaddress or name:
       //InetAddress addr =
      //   InetAddress.getByName("127.0.0.1");
       //InetAddress addr =
      //   InetAddress.getByName("localhost");
      System.out.println("addr = " + addr);
       Socketsocket =
        new Socket(addr, JabberServer.PORT);
       // Guard everything in a try-finally to make
       // sure thatthe socket is closed:

       try {
        System.out.println("socket = " + socket);
        BufferedReader KeyIn = new BufferedReader(newInputStreamReader(System.in));
        BufferedReader in =
          new BufferedReader(
            new InputStreamReader(
              socket.getInputStream()));
        // Output isautomatically flushed
        // by PrintWriter:

        PrintWriter out =
          new PrintWriter(
            new BufferedWriter(
              new OutputStreamWriter(
                socket.getOutputStream())),true);

//        for(int i = 0; i < 10; i ++) {
//          out.println("howdy " + i);
//          String str = in.readLine();
//          System.out.println(str);
//        }
//        out.println("END");
        String str =null;
        while(true)
        {
           str = KeyIn.readLine();
           if("END".equals(str))
              break;
           out.println(str);
          System.out.println("Server:"+in.readLine());
          
          
        }
       } finally{
        System.out.println("closing...");
        socket.close();
       }
     }
    }///:~

public class JabberServer { 
     // Choose a port outside of the range1-1024:
     public static final int PORT = 8088;
     public static void main(String[] args)
        throws IOException {
       ServerSockets = new ServerSocket(PORT);
      System.out.println("Started: " + s);
       try {
        Socket socket = s.accept();
        try {
          System.out.println(
            "Connection accepted: "+ socket);
          BufferedReader KeyIn = new BufferedReader(newInputStreamReader(System.in));
          
          BufferedReader in =
            new BufferedReader(
              new InputStreamReader(
                socket.getInputStream()));
          // Output is automatically flushed
          // by PrintWriter:

          PrintWriter out =
            new PrintWriter(
              new BufferedWriter(
                new OutputStreamWriter(
                  socket.getOutputStream())),true);

          while (true) { 
            String str = in.readLine();
            if (str.equals("END")) break;
            System.out.println("Client: " + str);
            out.println(KeyIn.readLine());
            
          }
         // Always close thetwo sockets...
        } finally {
          System.out.println("closing...");
          socket.close();
        }
       } finally{
        s.close();
       }
     }
    }///:~

注意:一般在传输字符信息(例如txt文件,聊天信息)使用bufferedRead,printWrite ,但是在传送一些文件时一定要使用字节输入输出流socket.getInputStream  和scoket.getOutputStream(但是使用上面的字符流传输文件时,当文件传送完毕时打开会报错!!!)

<think>好的,我现在需要帮助用户了解如何使用C# 7.3通过Socket底层实现局域网控制台程序,具备创建房间、搜索房间和加入房间的功能。首先,我得回忆一下C#中Socket编程的基础知识,确保自己理解正确。 用户可能是一个有一定C#基础但不太熟悉网络编程的开发者。他想在局域网内实现一个控制台程序,需要三个主要功能:创建房间、搜索房间和加入房间。我需要把这些功能分解成具体的技术实现步骤。 首先,创建房间应该对应一个服务器端的Socket,监听特定端口,等待客户端连接。搜索房间可能需要客户端广播UDP消息到局域网,然后服务器端响应自己的存在。加入房间则是客户端连接到服务器的指定端口。 接下来,我需要考虑协议的选择。TCP适合可靠的连接,用于房间内的通信,而UDP适合广播和发现服务,用于搜索房间。这样分开处理可能更高效。 然后,具体的实现步骤。对于服务器端(创建房间),需要绑定IP地址和端口,开始监听。客户端搜索房间时,发送UDP广播消息,服务器端接收到后回复自己的信息。客户端收到回复后显示可用房间,用户选择后通过TCP连接加入。 需要注意的问题包括:如何正确处理广播地址,如何异步处理多个客户端的连接,以及如何确保端口正确开放,避免防火墙拦截。此外,编码格式、消息协议的设计(比如使用字符串还是二进制数据)也需要考虑。 可能还需要处理多线程或异步操作,避免阻塞主线程。例如,服务器端在监听客户端连接时应该使用异步方法,如BeginAcceptSocket,而客户端搜索房间时需要发送UDP包并监听响应。 另外,测试时确保服务器和客户端在同一个局域网,关闭防火墙或设置例外规则,防止通信被阻止。可能需要演示代码结构,包括服务器和客户端的基本框架,以及UDP广播和响应的部分。 最后,要提醒用户可能的扩展方向,比如添加房间密码、状态同步或聊天功能,但当前先实现基础功能。需要确保代码示例正确,语法符合C#7.3,比如使用ValueTuple或者ref局部变量等特性,但可能在基础示例中用不上这些高级功能,保持代码简洁易懂更重要。 总结步骤:1. 设计协议结构;2. 实现服务器端的TCP监听;3. 实现客户端的UDP广播发现;4. 处理TCP连接加入房间。需要分部分讲解,每部分给出关键代码示例,并说明注意事项。</think>以下是通过C# 7.3实现局域网房间管理功能的底层Socket方案,分为技术实现步骤和代码示例: 一、基础架构设计 1. 协议选择 - TCP协议:用于房间创建和稳定通信(端口号示例:9999) - UDP协议:用于房间发现广播(端口号示例:9998) 2. IP地址处理 ```csharp IPAddress broadcastAddress = IPAddress.Parse("255.255.255.255"); IPEndPoint broadcastEP = new IPEndPoint(broadcastAddress, 9998); ``` 二、服务端实现(创建房间) 1. TCP监听核心代码 ```csharp // 创建TCP监听Socket Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); listener.Bind(new IPEndPoint(IPAddress.Any, 9999)); listener.Listen(10); // 异步接受连接 listener.BeginAccept(new AsyncCallback(AcceptCallback), listener); ``` 2. UDP广播响应处理 ```csharp // 创建UDP监听Socket UdpClient udpListener = new UdpClient(9998); // 接收广播请求 IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0); byte[] recvBytes = udpListener.Receive(ref remoteEP); // 响应房间信息 string response = "ROOM_AVAILABLE|Room1"; byte[] responseData = Encoding.ASCII.GetBytes(response); udpListener.Send(responseData, responseData.Length, remoteEP); ``` 三、客户端实现(搜索/加入房间) 1. 房间发现实现 ```csharp // UDP广播发送 UdpClient searcher = new UdpClient(); searcher.EnableBroadcast = true; byte[] searchMsg = Encoding.ASCII.GetBytes("DISCOVER_ROOMS"); searcher.Send(searchMsg, searchMsg.Length, broadcastEP); // 接收响应 var responseEP = new IPEndPoint(IPAddress.Any, 0); byte[] responseData = searcher.Receive(ref responseEP); string roomInfo = Encoding.ASCII.GetString(responseData); ``` 2. 加入房间实现 ```csharp // 建立TCP连接 Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); clientSocket.Connect(roomIP, 9999); // 验证连接 if (clientSocket.Connected) { Console.WriteLine("成功加入房间!"); } ``` 四、关键注意事项 1. 异步处理建议使用`SocketAsyncEventArgs`提升性能 2. 消息协议建议采用统一格式: ``` [命令类型]|[参数1]|[参数2](示例:"JOIN_ROOM|Player1") ``` 3. 需要处理多线程同步问题,推荐使用: ```csharp lock (_syncObject) { // 共享资源操作 } ``` 五、扩展建议 1. 增加房间心跳机制(30秒无响应自动移除) 2. 实现房间人数限制 3. 添加基础通信协议(示例): ```csharp public enum CommandType { RoomCreate = 1, PlayerJoin = 2, MessageSend = 3 } public class NetworkPacket { public CommandType Command { get; set; } public string Payload { get; set; } } ``` 完整实现需要约300行代码,建议采用模块化设计: - NetworkManager.cs:处理底层Socket通信 - RoomService.cs:实现房间业务逻辑 - ProtocolParser.cs:处理数据序列化/反序列化 实际部署时需确保: 1. 防火墙开放9999和9998端口 2. 所有设备处于同一子网 3. 禁用网络适配器的节能模式 可通过Wireshark抓包工具验证网络通信是否正常。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值