ServerSocket有以下几中常用的构造方法：

（1） ServerSocket()

（2） ServerSocket(int port)

（3） ServerSocket(int port, int backlog)

（4） ServerSocket(int port, int backlog, InetAddress bindAddr)

1、public Socket accept()；等待客户机的连接。若连接，则创建套接字。

2、public boolean isBound()；判断ServerSocket的绑定状态。

3、public InetAddress getInetAddress()；返回服务器套接字的本地地址。

4、public boolean isClosed()；返回服务器的套接字的关闭状态。

5、public void close()；关闭服务器套接字。

6、public void bind(SocketAddress endpoint)；将ServerSocket绑定到特定地址（IP和端口号）。

public Socket accept()；等待客户机的连接。若连接，则创建套接字。

public boolean isBound()；判断ServerSocket的绑定状态

public InetAddress getInetAddress()；返回服务器套接字的本地地址

public boolean isClosed()；返回服务器的套接字的关闭状态

public void close()；关闭服务器套接字

public void bind(SocketAddress endpoint)；将ServerSocket绑定到特定地址（IP和端口号）

1. Socket,ServerSocket 用于TCP/IP协议

2. 
   

3.  

4. 
   

5. (1)Socket:

6. 
   

7.  

8. 
   

9. 1.Socket 最常用构造方法:

10. 
    

11. <1>:public Socket(String host,int port);

12. 
    

13. host是连接所需服务器的名称或者ip地址 , port是端口号

14. 
    

15.  

16. 
    

17. 2. 最常用的两个方法:

18. 
    

19. <1>:public OutputStream getOutputStream()

20. 
    

21. 返回一个输出流，进行数据的传递;可以把返回的输出流进行再包装，传送数据更为方便

22. 
    

23. <2>:public InputStream getInputStream()

24. 
    

25. 返回一个输入流，进行数据的读取;也可以把输入流进行包装，读取数据时更为快捷

26. 
    

27. 3. 获取Socket的信息:

28. 
    

29. <1>:public InetAddress getInetAddress()

30. 
    

31. 获得服务器的IP地址

32. 
    

33. <2>:public int getPort()

34. 
    

35. 获得服务器的端口(一般由服务器随机设置的端口，与服务器端当初建立的时候端口不一致，稍微注意)

36. 
    

37. <3>:public InetAddress getLocalAddress()

38. 
    

39. 获取本地的地址

40. 
    

41. <4>:public int getLocalPort()

42. 
    

43. 获取本地的端口

44. 
    

45.  

46. 
    

47. 4. 关闭socket的连接（很重要，如果一个连接结束之后，不再使用，一定记着关闭，否则服务器就会负载过重造成崩溃）

48. 
    

49. <1>:public void close()

50. 
    

51. 关闭与服务器的连接

52. 
    

53. 5. 设置socket的选项，一些常用的配置

54. 
    

55. <1>:public void setTcpNoDelay(boolean on)

56. 
    

57. 默认为false,会先把数据缓存，到一定数量后一起发送；

58. 
    

59. 如果设为true，则会立即发送数据，常用作游戏设计中，服务器需要快速的得到客户端的响应

60. 
    

61. <2>:public void setReuseAddress(boolean on)

62. 
    

63. 当接收方的close()方法关闭socket时，网络上还有没发送到这个socket的数据，那么底层的socket不会立即释放本地端口，

64. 
    

65. 会等待一段时间，确保收到了网络上收到的数据，然后再释放端口；当在这个时间段里，又重新使用这个端口，会发送异常，如果设置

66. 
    

67. 属性为true,则会立即关闭底层socket，但是设置这个属性时，不能在创建socket的时候指定host，port；

68. 
    

69. <3>:public void setSoTimeout(int timeout)

70. 
    

71. 设置接受数据时的等待超时时间

72. 
    

73. <4>:public void setReceiveBufferSize(int size)

74. 
    

75. 设置接收数据的缓冲区的大小

76. 
    

77. <5>:public void setSendBufferSize(int size)

78. 
    

79. 设置发送数据缓冲区的大小

80. 
    

81. (2)：ServerSocket

82. 
    

83. 1. 构造函数

84. 
    

85. <1>public ServerSocket(int port)

86. 
    

87. port：指定端口号

88. 
    

89. <2>public ServerSocket(int port,int backlog)

90. 
    

91. port是端口号，backlog，指定请求队列的长度

92. 
    

93. 2. 最常用的一个方法

94. 
    

95. <1>:public Socket accept()

96. 
    

97. 接受一个客户的请求，很重要的一个方法，建立与客户的联系；

98. 
    

99. 是一个阻塞方法，如果没有用户的请求，会一直等待

100. 
     

101. 3.  获取一些信息

102. 
     

103. <1>:public InetAddress getInetAddress()

104. 
     

105. <2>:public int getLocalPort()

106. 
     

107. 4. ServerSocket选项

108. 
     

109. <1>public void setSoTimeout(int timeout)

110. 
     

111. · 设置等待客户连接的超时时间

112. 
     

113. <2>public void setReuseAddress(boolean on)

114. 
     

115. 设置是否允许重用服务器锁绑定的地址

116. 
     

117. <3>public void setReceiveBufferSize(int size)

118. 
     

119. 设置接受数据的缓冲区的大小

120. ————————————————

121. 版权声明：本文为CSDN博主「haoran_10」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

122. 原文链接：https://blog.csdn.net/haoran_10/article/details/88330000

在客户/服务器通信模式中，服务器端需要创建监听特定端口的ServerSocket，ServerSocket负责接收客户连接请求，并生成与客户端连接的Socket。

1、构造ServerSocket

ServerSocket的构造方法有以下几种重载形式：

• ServerSocket()throws IOException

• ServerSocket(int port) throws IOException

• ServerSocket(int port, int backlog) throws IOException

• ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException

在以上构造方法中，参数port指定服务器要绑定的端口（服务器要监听的端口），参数backlog指定客户连接请求队列的长度，参数bindAddr指定服务器要绑定的IP地址。

1.1 、绑定端口

除不带参数的构造方法以外，其他构造方法都会使服务器与特定端口绑定，该端口由参数port指定。如果端口被其他服务进程占用，或是，在某些系统中，若没有以超级用户身份运行服务器程序，操作系统不允许服务器绑定到1-1023的端口时，会抛出BindException。

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

当服务器进程运行时，可能会同时监听到多个客户的连接请求。管理客户端连接请求的任务是由操作系统来完成的。操作系统将连接请求存储在一个先进先出队列中。许多操作系统限定了队列的最大长度，一般为50。当队列中的连接请求达到了队列的最大容量时，服务器进程所在的主机会拒绝新的连接请求。只有当服务器进程通过ServerSocket的accept()方法从队列中取出连接请求，使队列腾出空位时，队列才能继续加入新的连接请求。

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

ServerSocket构造方法的backlog参数用来显式设置连接请求队列的长度，它将覆盖操作系统限定的队列的最大长度。

在一下集中情况，仍然采用操作系统限定的队列最大长度：

• backlog参数的值大于操作系统限定的队列的最大长度；

• backlog参数的值小于或等于0；

• 在ServerSocket构造方法中没有设置backlog参数。

1.3、设定绑定的IP地址

若主机只有一个地址，则服务器默认绑定该地址；若主机有多个地址，则可以调用ServerSocket(int port, int backlog, InetAddress bindAddr)构造方法设置主机ip地址。

1.4、默认构造方法的作用

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

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

2、接收和关闭与客户的连接

ServerSocket的accept()方法从连接请求队列中取出一个客户的连接请求，然后创建与客户连接的Socket对象，并将它返回。如果队列中没有连接请求，accept()方法就会一直等待，直到接收到了连接请求才返回。

服务器从Socket对象中获得输入流和输出流

，就能与客户交换数据。当服务器正在进行发送数据的操作时，如果客户端断开了连接，那么服务器端会抛出一个IOException的子类SocketException异常：java.net.SocketException: Connection reset by peer。

3、关闭ServerSocket

ServerSocket的close()方法使服务器释放占用的端口，并且断开与所有客户的连接。当一个服务器程序运行结束时，即使没有执行ServerSocket的close()方法，操作系统也会释放这个服务器占用的端口。因此，服务器程序并不一定要在结束之前执行ServerSocket的close()方法。

在某些情况下，如果希望及时释放服务器的端口，以便让其他程序能占用该端口，则可以显式调用ServerSocket的close()方法。

ServerSocket的isClosed()方法判断ServerSocket是否关闭，只有执行了ServerSocket的close()方法，isClosed()方法才返回true；否则，即使ServerSocket还没有和特定端口绑定，isClosed()方法也会返回false。

ServerSocket的isBound()方法判断ServerSocket是否已经与一个端口绑定，只要ServerSocket已经与一个端口绑定，即使它已经被关闭，isBound()方法也会返回true。

4、获取ServerSocket的信息

• public InetAddress getInetAddress()：获取服务器绑定的ip地址；

• public int getLocalPort()：获取服务器绑定的端口；

在构造ServerSocket时，如果把端口设为0，那么将由操作系统为服务器分配一个端口（称为匿名端口），程序只要调用getLocalPort()方法就能获知这个端口号。多数服务器会监听固定的端口，这样才便于客户程序访问服务器。匿名端口一般适用于服务器与客户之间的临时通信，通信结束，就断开连接，并且ServerSocket占用的临时端口也被释放。

5、ServerSocket选项

ServerSocket有以下3个选项。

• SO_TIMEOUT：表示等待客户连接的超时时间。

• SO_REUSEADDR：表示是否允许重用服务器所绑定的地址。

• SO_RCVBUF：表示接收数据的缓冲区的大小。

5.1、SO_TIMEOUT选项

• 设置该选项：public void setSoTimeout(int timeout) throws SocketException

• 读取该选项：public int getSoTimeout () throws IOException

SO_TIMEOUT表示ServerSocket的accept()方法等待客户连接的超时时间，以毫秒为单位。 如果SO_TIMEOUT的值为0，表示永远不会超时，这是SO_TIMEOUT的默认值。

当服务器执行ServerSocket的accept()方法时，如果连接请求队列为空，服务器就会一直等待，直到接收到了客户连接才从accept()方法返回。如果设定了超时时间，那么当服务器等待的时间超过了超时时间，就会抛出SocketTimeoutException，它是InterruptedException的子类。

5.2、SO_REUSEADDR选项

• 设置该选项：public void setResuseAddress(boolean on) throws SocketException

• 读取该选项：public boolean getResuseAddress() throws SocketException

这个选项与Socket的SO_REUSEADDR选项相同，用于决定如果网络上仍然有数据向旧的ServerSocket传输数据，是否允许新的ServerSocket绑定到与旧的ServerSocket同样的端口上。SO_REUSEADDR选项的默认值与操作系统有关，在某些操作系统中，允许重用端口，而在某些操作系统中不允许重用端口。

当ServerSocket关闭时，如果网络上还有发送到这个ServerSocket的数据，这个ServerSocket不会立刻释放本地端口，而是会等待一段时间，确保接收到了网络上发送过来的延迟数据，然后再释放端口

许多服务器程序都使用固定的端口。当服务器程序关闭后，有可能它的端口还会被占用一段时间，如果此时立刻在同一个主机上重启服务器程序，由于端口已经被占用，使得服务器程序无法绑定到该端口，服务器启动失败，并抛出BindException。

为了确保一个进程关闭了ServerSocket后，即使操作系统还没释放端口，同一个主机上的其他进程还可以立刻重用该端口，可以调用ServerSocket.setResuseAddress(true)方法

5.3、SO_RCVBUF选项

• 设置该选项：public void setReceiveBufferSize(int size) throws SocketException

• 读取该选项：public int getReceiveBufferSize() throws SocketException

SO_RCVBUF表示服务器端的用于接收数据的缓冲区的大小，以字节为单位。一般说来，传输大的连续的数据块（基于HTTP或FTP协议的数据传输）可以使用较大的缓冲区，这可以减少传输数据的次数，从而提高传输数据的效率。而对于交互式的通信（Telnet和网络游戏），则应该采用小的缓冲区，确保能及时把小批量的数据发送给对方。

5.4、设定连接时间、延迟和带宽的相对重要性

public void setPerformancePreferences(int connectionTime,int latency,int bandwidth)

该方法的作用与Socket的setPerformancePreferences()方法的作用相同，用于设定连接时间、延迟和带宽的相对重要性。

6、创建多线程服务器

许多实际应用要求服务器具有同时为多个客户提供服务的能力。HTTP服务器就是最明显的例子。任何时刻，HTTP服务器都可能接收到大量的客户请求，每个客户都希望能快速得到HTTP服务器的响应。如果长时间让客户等待，会使网站失去信誉，从而降低访问量。

可以用并发性能来衡量一个服务器同时响应多个客户的能力。一个具有好的并发性能的服务器，必须符合两个条件：

• 能同时接收并处理多个客户连接；

• 对于每个客户，都会迅速给予响应。

用多个线程来同时为多个客户提供服务，这是提高服务器的并发性能的最常用的手段。

以下将按照3中方式来实现EchoServer，它们都使用多线程。

• 为每个客户分配一个工作线程。

• 创建一个线程池，由其中的工作线程来为客户服务。

• 利用JDK的Java类库中现成的线程池，由它的工作线程来为客户服务。

6.1、 为每个客户分配一个线程

服务器的主线程负责接收客户的连接，每次接收到一个客户连接，就会创建一个工作线程，由它负责与客户的通信。

代码示例：

public static void start(){
  try{
    ServerSocket serverSocket = new ServerSocket(PORT);
    System.out.println("server listen on port:" + PORT);
    while (true){
      try {
        Socket client = serverSocket.accept();
        System.out.println("receive client connect, localPort=" + client.getPort());
        new Thread(new EchoServer.HandlerServer(client)).start();
      }catch (Exception e){
        System.out.println("client exception,e=" + e.getMessage());
      }
    }
  }catch(Exception e){
    System.out.println("server exception,e=" + e.getMessage());
  }}

以上工作线程执行HandlerServer的run()方法，其负责与单个客户端通信，通信完毕后断开连接，线程自然终止。

6.2、创建线程池

对每个客户都分配一个新的工作线程。当工作线程与客户通信结束，这个线程就被销毁。这种实现方式有以下不足之处：

• 服务器创建和销毁工作线程的开销（包括所花费的时间和系统资源）很大。如果服务器需要与许多客户通信，并且与每个客户的通信时间都很短，那么有可能服务器为客户创建新线程的开销比实际与客户通信的开销还要大。

• 除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。每个线程本身都会占用一定的内存（每个线程需要大约1M内存），如果同时有大量客户连接服务器，就必须创建大量工作线程，它们消耗了大量内存，可能会导致系统的内存空间不足。

• 如果线程数目固定，并且每个线程都有很长的生命周期，那么线程切换也是相对固定的。不同操作系统有不同的切换周期，一般在20毫秒左右。这里所说的线程切换是指在Java虚拟机，以及底层操作系统的调度下，线程之间转让CPU的使用权。如果频繁创建和销毁线程，那么将导致频繁地切换线程，因为一个线程被销毁后，必然要把CPU转让给另一个已经就绪的线程，使该线程获得运行机会。在这种情况下，线程之间的切换不再遵循系统的固定切换周期，切换线程的开销甚至比创建及销毁线程的开销还大。

线程池为线程生命周期开销问题和系统资源不足问题提供了解决方案。线程池中预先创建了一些工作线程，它们不断从工作队列中取出任务，然后执行该任务。当工作线程执行完一个任务时，就会继续执行工作队列中的下一个任务。线程池具有以下优点

• 减少了创建和销毁线程的次数，每个工作线程都可以一直被重用，能执行多个任务。

• 可以根据系统的承载能力，方便地调整线程池中线程的数目，防止因为消耗过量系统资源而导致系统崩溃。

6.3、使用JDK类库提供的线程池

java.util.concurrent包提供了现成的线程池的实现，其比自己实现的线程池更加健壮，且功能也更加强大。

Executor接口继承图.png

Executor接口表示线程池，它的execute(Runnable task)方法用来执行Runnable类型的任务。Executor的子接口ExecutorService中声明了管理线程池的一些方法，比如用于关闭线程池的shutdown()方法等。Executors类中包含一些静态方法，它们负责生成各种类型的线程池ExecutorService实例。

Executors类的静态方法.png

6.4、使用线程池注意事项

虽然线程池能大大提高服务器的并发性能，但使用它也会存在一定风险。与所有多线程应用程序一样，用线程池构建的应用程序容易产生各种并发问题，如对共享资源的竞争和死锁。此外，如果线程池本身的实现不健壮，或者没有合理地使用线程池，还容易导致与线程池有关的死锁、系统资源不足和线程泄漏等问题。

6.4.1、死锁

任何多线程应用程序都有死锁风险。造成死锁的最简单的情形是，线程A持有对象X的锁，并且在等待对象Y的锁，而线程B持有对象Y的锁，并且在等待对象X的锁。线程A与线程B都不释放自己持有的锁，并且等待对方的锁，这就导致两个线程永远等待下去，死锁就这样产生了。

虽然任何多线程程序都有死锁的风险，但线程池还会导致另外一种死锁。在这种情形下，假定线程池中的所有工作线程都在执行各自任务时被阻塞，它们都在等待某个任务A的执行结果。而任务A依然在工作队列中，由于没有空闲线程，使得任务A一直不能被执行。这使得线程池中的所有工作线程都永远阻塞下去，死锁就这样产生了。

6.4.2、系统资源不足

如果线程池中的线程数目非常多，这些线程会消耗包括内存和其他系统资源在内的大量资源，从而严重影响系统性能。

6.4.3．并发错误

线程池的工作队列依靠wait()和notify()方法来使工作线程及时取得任务，但这两个方法都难于使用。

如果编码不正确，可能会丢失通知，导致工作线程一直保持空闲状态，无视工作队列中需要处理的任务。因此使用这些方法时，必须格外小心，即便是专家也可能在这方面出错。最好使用现有的、比较成熟的线程池。例如，直接使用java.util.concurrent包中的线程池类。

6.4.4．线程泄漏

使用线程池的一个严重风险是线程泄漏。对于工作线程数目固定的线程池，如果工作线程在执行任务时抛出RuntimeException 或Error，并且这些异常或错误没有被捕获，那么这个工作线程就会异常终止，使得线程池永久失去了一个工作线程。如果所有的工作线程都异常终止，线程池就最终变为空，没有任何可用的工作线程来处理任务。

导致线程泄漏的另一种情形是，工作线程在执行一个任务时被阻塞，如等待用户的输入数据，但是由于用户一直不输入数据（可能是因为用户走开了），导致这个工作线程一直被阻塞。这样的工作线程名存实亡，它实际上不执行任何任务了。假如线程池中所有的工作线程都处于这样的阻塞状态，那么线程池就无法处理新加入的任务了。

6.4.5．任务过载

当工作队列中有大量排队等候执行的任务时，这些任务本身可能会消耗太多的系统资源而引起系统资源缺乏。

综上所述，线程池可能会带来种种风险，为了尽可能避免它们，使用线程池时需要遵循以下原则。

（1）如果任务A在执行过程中需要同步等待任务B的执行结果，那么任务A不适合加入到线程池的工作队列中。如果把像任务A一样的需要等待其他任务执行结果的任务加入到工作队列中，可能会导致线程池的死锁。

（2）如果执行某个任务时可能会阻塞，并且是长时间的阻塞，则应该设定超时时间，避免工作线程永久的阻塞下去而导致线程泄漏。在服务器程序中，当线程等待客户连接，或者等待客户发送的数据时，都可能会阻塞。可以通过以下方式设定超时时间：

◆调用ServerSocket的setSoTimeout(int timeout)方法，设定等待客户连接的超时时间；

◆对于每个与客户连接的Socket，调用该Socket的setSoTimeout(int timeout)方法，设定等待客户发送数据的超时时间。

（3）了解任务的特点，分析任务是执行经常会阻塞的I/O操作，还是执行一直不会阻塞的运算操作。前者时断时续地占用CPU，而后者对CPU具有更高的利用率。预计完成任务大概需要多长时间？是短时间任务还是长时间任务？

根据任务的特点，对任务进行分类，然后把不同类型的任务分别加入到不同线程池的工作队列中，这样可以根据任务的特点，分别调整每个线程池。

（4）调整线程池的大小。线程池的最佳大小主要取决于系统的可用CPU的数目，以及工作队列中任务的特点。假如在一个具有 N 个CPU的系统上只有一个工作队列，并且其中全部是运算性质（不会阻塞）的任务，那么当线程池具有 N 或 N+1 个工作线程时，一般会获得最大的 CPU 利用率。

如果工作队列中包含会执行I/O操作并常常阻塞的任务，则要让线程池的大小超过可用CPU的数目，因为并不是所有工作线程都一直在工作。选择一个典型的任务，然后估计在执行这个任务的过程中，等待时间（WT）与实际占用CPU进行运算的时间（ST）之间的比例WT/ST。对于一个具有N个CPU的系统，需要设置大约N×(1+WT/ST)个线程来保证CPU得到充分利用。

当然，CPU利用率不是调整线程池大小过程中唯一要考虑的事项。随着线程池中工作线程数目的增长，还会碰到内存或者其他系统资源的限制，如套接字、打开的文件句柄或数据库连接数目等。要保证多线程消耗的系统资源在系统的承载范围之内。

（5）避免任务过载。服务器应根据系统的承载能力，限制客户并发连接的数目。当客户并发连接的数目超过了限制值，服务器可以拒绝连接请求，并友好地告知客户：服务器正忙，请稍后再试。

1.accept：侦听并接受此套接字的连接；此方法在连接传入之前一直阻塞。

2.setSoTimeout(timeout)方法的作用时设置超时时间，通过指定超时timeout值启用/禁用超时功能，以ms为单位。

　　必须在进入阻塞前调用这个方法，才能生效，一旦超时，程序会触发SocketTimeoutException异常；默认值是0即永远等待。

Server.java

package com.company.s7;import java.io.IOException;import java.net.ServerSocket;public class Server {    public static void main(String[] args) {        try {
            ServerSocket serverSocket=new ServerSocket(8000);
            System.out.println(serverSocket.getSoTimeout());
            serverSocket.setSoTimeout(4000);
            System.out.println(serverSocket.getSoTimeout());
            System.out.println();

            System.out.println("begin "+System.currentTimeMillis());
            serverSocket.accept();
            System.out.println(" end "+System.currentTimeMillis());
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

Client.java

package com.company.s7;import java.io.IOException;import java.net.Socket;public class Client {    public static void main(String[] args) {        try {
            System.out.println("client begin "+System.currentTimeMillis());
            Socket socket=new Socket("localhost",8000);
            System.out.println("client end "+System.currentTimeMillis());
        }catch (IOException e){
            e.printStackTrace();
            System.out.println("catch "+System.currentTimeMillis());
        }
    }
}

backlog参数含义：

允许接受客户端连接请求的个数。

如果队列已满，则拒接该连接。

blacklog参数如果小于等于0，则使用默认值50；

Server.java

package com.company.s71;import javax.sound.midi.Soundbank;import java.io.IOException;import java.net.ServerSocket;import java.net.Socket;public class Server {    public static void main(String[] args) throws IOException, InterruptedException {
        ServerSocket serverSocket=new ServerSocket(8088,3);        //sleep(5000)的作用是不让ServerSocket调用accept()方法，        //而是由客户端Socket先发奇10个连接请求        //然后在执行accept方法时只能接收3个连接
        Thread.sleep(5000);

        System.out.println("accept1 begin");
        Socket socket1=serverSocket.accept();
        System.out.println("accept1 end");

        System.out.println("accept2 begin");
        Socket socket2=serverSocket.accept();
        System.out.println("accept2 end");

        System.out.println("accept3 begin");
        Socket socket3=serverSocket.accept();
        System.out.println("accept3 end");

        System.out.println("accept4 begin");
        Socket socket4=serverSocket.accept();
        System.out.println("accept4 end");

        System.out.println("accept5 begin");
        Socket socket5=serverSocket.accept();
        System.out.println("accept5 end");

        socket1.close();
        socket2.close();
        socket3.close();
        socket4.close();
        socket5.close();

        serverSocket.close();
    }
}

Client.java

package com.company.s71;import java.io.IOException;import java.net.Socket;public class Client {    public static void main(String[] args) throws IOException {
        Socket socket1=new Socket("localhost",8088);
        Socket socket2=new Socket("localhost",8088);
        Socket socket3=new Socket("localhost",8088);
        Socket socket4=new Socket("localhost",8088);      //  Socket socket5=new Socket("localhost",8088);
    }
}

先启动server.java，然后快速的启动client.java；

但是让我很奇怪的是服务端启动五秒之后，再启动客户端，反而能正确的执行；