日升时奋斗，日落时自省 

目录

1、网络编程基本概念

2、UDP数据报套接字编程

2.1、UDP相关API

2.1.1、DatagramSocket API

2.1.2、DatagramPacket API

 2.2、UDP版本服务器

 2.3、UDP版本客户端

 2.4、UDP连接操作

2.5、翻译业务

2.6、总结

 3、TCP流套接字编程

3.1、TCP相关API

3.2、TCP版本服务器

 3.3、TCP版本的客户端

 3.4、TCP连接操作

3.4.1多线程TCP服务器

3.4.2、线程池TCP服务器

---

1、网络编程基本概念

网络编程指的是网络上的主机，通过不同的进程，以编程的方式进行实现网络通信

详细下来就是我们只要满足进程不同就行；所以即使是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程

（1）发送端和接收端

发送端：数据的发送方进程 ，称为发送端，发送端就是网络通信的源主机

接收端：数据的接收方进程， 称为接收端，接收端就是网络通信中的目的主机

注：发送端和接收端只是相对的。

（2）请求和响应

一般情况，获取一个网络资源，涉及到两次网络数据传输

首先： 请求数据发送

然后：响应数据发送

例如 ：餐馆买饭，客人发出请求（我要吃什么），餐馆针对请求做出处理（后厨颠勺中），最后做好针对客人进行响应（做好了给你）

 （3）客户端和服务端

服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务

客户端：获取服务的一方进程，称为客户端

注：我们常说的客户端（发送端）和服务器（接收端），但是理解不单就是客户与服务器交互，如果是服务器与服务器交互谁又是客户端（发送端）其实就是看谁给谁发送请求，发送请求的就是发送端，接收请求的就是接收端

2、UDP数据报套接字编程

2.1、UDP相关API

基于UDP来编写一个简单的客户端服务器进行网络通信程序；需要有一定的网络基础

首先就是要认识进行网络编程要使用的API

核心内容 Socket API，操作系统给应用程序提供的网络编程API；Socket这里翻译成套接字，它是计算机之间进行通信的一种约定或一种方式；虽然socket英译为“插座”，但是在计算机领域里它叫“套接字”。

可以认为socket API是和传输层密切相关的，传输层提供了两个最核心的协议UDP和TCP所以socket也提供了两种风格的API

DatagramSocket使用这个类，表示一个socket对象，代表socket文件；原因：在操作系统中，把这个socket对象也是当成了一个文件来处理，相当于是文件描述符表上的一项，提到这里就会想到普通文件也就是对应的硬件设备（硬盘），socket文件，对应的硬件设备（网卡）一切都是文件而起。

一个socket对象，就可以和另外一台主机进行通信，如果要和多个不同的主机通信，需要创建多个socket对象。

2.1.1、DatagramSocket API

DatagramSocket是UDP Socket用于发送和接收UDP数据报 （这里稍微有点绕口，多看两遍）

这个绕口的话是解释：DatagramSocket与下面马上要提到DatagramPacket对比理解，实际意思就是DatagramSocket里面是数据报作为参数也就是DatagramPacket类的（它就是作参数的）

（1）无参数版本的构造方法，没有指定端口，系统会自动分配一个空闲的端口

 （2）一个参数版本的构造方法，有一个端口号，此时就是为了socket对象能和指定的端口号（简单的数字范围在1024-65535之间），关联起来；我们知道端口号是和进程相关连的，为了确定是哪个进程，本质上不是进程和端口号建立联系，而是进程中的socket对象和端口建立了联系

（3）需要了解的方法 一个receive（接收）另一个是send（发送）

 receive方法此处有一个DatagramPacket的参数，但是这里填的相当于是一个空对象，receive方法内部会对参数的这个空对象进行内容填充（将接收来的数据填充），从而构造出结果数据，参数也是一个“输出型参数”  如果没有接收到数据 会进行阻塞等待

send方法也有一个DatagramPacket参数，这里的参数就有数据了，从此套接字发送数据报

 最后一个使用需用方法就是close 关闭此数据报套接字

2.1.2、DatagramPacket API

DatagramPacket是UDP socket发送和接收的数据报

DatagramPacket表示UDP中传输的一个报文，构造这个对象可以指定一些具体的数据进去，这些数据后面实现UDP的时候会展示

（1）2个参数版本的构造方法

把buf这个缓冲区给设置进去，数据存储先放在缓存区上，既然是文件就需要涉及到文件操作，当然内部会自己处理，我们直接使用网络编程相关API就可以了（最后一个参数是缓冲区设置的长度）

（2）4个参数版本的构造方法

 构造缓冲区、起始位置、缓冲区长度、地址（这个地址包括两个内容IP地址 和 端口号port）

这里提到一个InetSocketAddress 的API 它也有自己得构造方法，里面包含两个参数一个IP地址，另一个是端口号

 2.2、UDP版本服务器

我们这里做的是自己本机电脑的服务器，就是本机连接本机 称为回显服务器（echo server）

一个普通的服务器的构造需要涉及这几步：收到请求，根据请求计算响应，返回响应

Echo server 省略了其中的“根据请求计算响应”，实现的这个程序是请求啥返回啥，主要针对socket API基本用法的理解，这里不写“请求计算响应”不是它不重要，它是最重要的，但是实现需要对应的业务，这个等socket会用了再实现一个比较简单业务给友友们理解

提示：我们这里自定义了一个类 叫做： UdpEchoServer 以下UDP服务器代码都是包含在这个类中

第一步：

网络编程操作本身就是操作网卡的，但是网卡不方便直接操作，在操作系统内核中，使用了一个特殊的叫做“socket”这样的文件来抽象表示网卡，因此进行网络通信是势必要有一个Socket

private DatagramSocket socket=null;

第二步：

 这里是我们自己实现一个UDP版本的服务器，socket当前置空的原因是为了在该类的构造方法中添加输入自己的端口号，创建socket对象的同时，给他绑定一个端口号；

public UdpEchoServer(int port) throws SocketException {
        //构造方法中有一个参数就是 端口号 在socket创建对象的时候传入端口号
        socket=new DatagramSocket(port);
    }

为什么要关联一个具体端口号？？？

因为客户端是需要通过服务器的端口号来给服务器发送请求，那前面不是说如果不分配的话操作系统会分配一个随机的端口号吗？如果是这样的话，客户端就不知道这个端口号是什么了，也就没有办法进行通信了。

第三步：

思路:
(1)创建一个执行start方法,因为客户端肯定是不会就发发送一次请求的,会有多次,所以服务器一般都是7*24小时工作的,这里会写一个while(true)循环保持服务器不会断开.

(2)那循环内需要的就是网络所需的基础 : 接收请求 , 根据请求计算响应  ,  返回响应(这里我们细说)

接收请求:

针对UDP来说传输数据的基本单位是"数据报" 对应的类就是DatagramPacket,首先就是读取客户端的请求,需要使用receive方法 ,该方法的参数是一个输出型参数,这个参数就要是一个空的DatagramPacket对象,需要DatagramPacket对象创建对象

 DatagramPacket对象中传了两个参数 ,一个缓冲区,另一个该对象缓冲区的的长度;创建对象后传参给receive,如果客户端有数据传入receive内部会针对参数对象填充数据(该数据来自网卡),如果客户端没有数据传入receive会进行阻塞

 根据请求计算响应:

此时DatagramPacket是一个特殊的对象,并不直接进行数据处理,可以把来面的数据转化为字符串进行处理

获取字符串之后,就可以进行处理了(这里获取字符串的原因就是为了便于我们做处理);

 因为我们这里是走一下流程,所以没有写请求处理,知道要写这个就行.

返回响应:

把响应写回客户端,使用方法 send的参数也是DatagramPacket 对象,需要把返回对象构造好,此处构造对象就不在是空字节数了,而是使用响应数据来构造的

 到了这里UDP的客户端就写完了.(以上都是图片方便看解析,下面附有代码)

public void start() throws IOException {
        System.out.println("服务器启动");
        //服务器不是只给一个客户端提供服务系统就完了，一定会有很多的客户端
        while(true){
            /*
            * 只要客户端来了，就提供服务
            * 1、读取客户端发来的请求是啥
            * receive 方法的参数是一个输出型参数 需要先构造一个空白的DatagramPacket对象 ，交给receive来进行填充
            * */
            DatagramPacket requestPacker=new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacker);  //将接受传来的数据放入的当前的缓冲区
            //此时这个 DatagramPacket 是一个特殊的对象， 并不方便直接进行处理 可以把这里包含的数据拿出来，构造成一个字符串
            String requset =new String (requestPacker.getData(),0,requestPacker.getLength());
            //2、根据请求计算响应， 由于此处是回显服务器 ，响应和请求相同
            String response=process(requset);
            /*
            * 3、把响应写回到客户端 ，send的参数也是 DatagramPacket 需要把这个 Packet对象构造好
            * 此处构造的响应对象 不能是用空的字节数 构造了，而是要使用响应数据来构造
            * */
            DatagramPacket responsePacket=new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacker.getSocketAddress());
            socket.send(responsePacket);
            //4、打印一下， 当前这次请求响应处理中间结束
            System.out.printf("[%s: %d] req:%s ,resp:%s\n",responsePacket.getSocketAddress().toString(),
                    responsePacket.getPort(),requset,response);
        }
    }
    public String process(String requset) {
        return requset;
    }

最后一行还进行了打印,这里也对其进行解释:

 main方法操作：

 2.3、UDP版本客户端

这里的客户端是为了连接上面的服务器，待这里客户端写好以后友友们就可以自行尝试。

提示：这里客户端创建一个自定义类我这里叫做： UdpEchoClient 以下所有UDP客户端代码都在这个类中

第一步：
创建我们需要的变量 UDP客户端也需要socket文件来传输数据 ，需要创建一个 socket对象，同时还要知道服务器的IP地址和 端口号才能发送数据。

    private DatagramSocket socket=null;
    private  String serverIP=null;
    private  int serverPort=0;
    /*
    * 一次通信 ，需要有两个 IP 两个端口
    * 客户端 IP 是 127.0.0.1
    * 客户端的 port 是系统自动分配的
    * 服务器 IP 和 端口 也需要告诉客户端 ，才能顺利把这个消息发给服务器
    * */
    /*
    * 客户端这里为啥没有 个一个具体的端号  因为服务器不是本机 客户的主机上可能已经运行了很多的程序就会导致你设置的端口 号是被重复，会产生冲突
    * */
    public  UdpEchoClient(String serverIP ,int serverPort) throws SocketException {
        socket=new DatagramSocket();
        this.serverIP=serverIP;
        this.serverPort=serverPort;
    }

这里可能会有友友们问到为啥服务器有自己自己的端口号，这里为什么没有提到客户端具体的端口号？？

答案：客户端的端口号是系统自动分配的（分配一个空闲的端口号），那可以自己给客户端定义一个具体的端口号吗？勉强可以，因为客户端上有可能有很多程序，每个程序都有自己的端口号，如果自己定义就可能会产生冲突；

举个例子：你去吃饭，人多的时候就会给你一个牌牌，叫到你，你来领餐，但是此时你就是想要66号牌牌，但是可能这个牌牌已经被人领走了（该饭店就是一个客户端，餐牌就是端口号，客户端会系统自动分配端口号，你强行要一个餐牌就可能已经被（其他程序）拿走了造成冲突）

第二步：

写一个start方法进行运行 ：思路服务器大同小异（反向操作）

 while（true）循环中执行：写数据进行判断结束、发送数据、接收数据、控制台打印

写数据进行判断：

 发送数据：

 接收数据：

 控制台打印：

 以上图片解析比较零散，以下附有以上解释的代码

public void start() throws IOException {
        System.out.println("客户端启动 ");
        Scanner scanner=new Scanner(System.in);
        while(true){
            //1、从控制台读取发送的数据
            System.out.println("> ");
            String request=scanner.next();
            if(request.equals("exit")){
                System.out.println("结束");
                break;
            }
            /*
            * 2、构造成UDP 请求 并发送
            *   构造这个Packet 的时候 ，需要把serverIP 和 port 都传入过来 但是此处IP地址是一个32位的二级制的整数
            *   上述的IP地址是一个字符串 需要使用 InetAddress.getByName来进行一个转换
            * */
            DatagramPacket requestPacket=new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            //3、读取服务器的UDP 响应 并解析
            DatagramPacket responsePacket=new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response=new String(responsePacket.getData(),0,responsePacket.getLength());
            //4、把解析好的结果显示出来
            System.out.println(response);
        }
    }

main方法操作：

和UDP服务器操作基本相同，但是需要 服务器的IP地址和服务器的端口号

 2.4、UDP连接操作

首先这里先说怎么检测你的服务器和客户端都是写好的可以运行了：

以上连接操作是怎么进行，代码详细分解

2.5、翻译业务

以下带有业务的服务器继承了上面UDP版本服务器进行的

    //字典服务器 用来继承既可以
    //DictServer 来说 和 EchoServer 相比 大部分的东西都是一样的
    //主要是请求计算机响应是不一样的
public class UdpDictServer extends  UdpEchoServer {
    //这里是一个简单的翻译  使用到了Map  第一个泛型参数是接收单词 第二个泛型参数是 翻译过来的汉语
    private Map<String ,String> dict=new HashMap<>();
    //应用服务器这里需要继承父类 构造方法里面就可以写对应的东西
    public UdpDictServer(int port) throws SocketException {
        super(port);
        /*
        * 给当前 继承服务器 设置内容
        * 此处可以无限键值对  以下就是翻译内容 当然这里只是为了方便友友们看， 实际自己想实现点简单的业务也是可以的
        * */
        dict.put("cat","小猫");
        dict.put("dog","小狗");
        dict.put("fuck","卧槽");
    }
    //继承了也就需要 重写 UdpEchoServer的方法
    public String process(String request){
        //查词典的过程
        return dict.getOrDefault(request,"当前单词没有查到结果");
        //这里就是 看是否是默认值 , 如果有就是用当前值 如没有的话就是用默认值
    }
    public static void main(String[] args) throws IOException {
        //本次只需要掉用该服务器就可以了
        UdpDictServer server=new UdpDictServer(9090);
        server.start();
    }
}

这里就是简单的业务实现，上面给了注释，代码不多也很好理解，重点理解前面的服务器和客户端代码，这里就不难看懂了。

以下演示以下，该带有业务的服务器跑起来 与客户端 联用

2.6、总结

（1）服务器的端口 是固定指定的，目的是为了方便客户找到服务器程序

（服务器是我们自己手里的机器，上面运行啥，都是我们控制的，指定安排空闲端口即可）

从哪里看 ，可以有两个地方看： 任务管理器友友们应该都很熟悉（Ctrl+alt+del 后点击任务管理器）以下点击就能查看PID（Process ID）其实是进程号（也是独一无二的）

 另一种方法就是命令行查看 涉及cmd命令 netstat -ano  (命令行打开操作： win+r 弹出框输入cmd)

 这里只截取了一部分作为演示，能理解就行

（2）客户端的端口 是由系统分自动分配的，如果手动指定，可能能会造成其他程序的端口的冲突

（客户端上的程序是不可控的，系统分配是最好的，服务器上的端口号是可控的，因为程序员可以自己看见，或者自查）

（3）端口冲突

端口冲突会有以下提醒 ，这里以服务器作为当前的端口冲突来解释

上面已经提及了两个服务器，一个UPD版本的服务器，另一个翻译业务的服务器 两个服务器同时用一个9090端口号就会产生冲突

 3、TCP流套接字编程

3.1、TCP相关API

TCP API主要涉及两个类

ServerSocket 专门给服务器使用的Socket对象 

Socket 是既能给 客户端是用也能给服务器使用 （知道这里不是很好理解，往后面看结合代码理解）

TCP和UDP传输数据不一样 UDP是“数据报” 但是TCP不是 而是以“字节”的方式 流式传输

ServerSocket一个参数构造方法

 创建一个服务器套接字Socket，并绑定到指定端口

使用方法就有所变化 ，检测方法Socket.accept()开始监听指定端口，有客户端；连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接 ，否则阻塞等待 ，这里明显与UDP的服务器不同了，体现了TCP的有连接的特性

关闭此套接字 close()方法

这里相当于是连接，看是否连接上客户端，TCP 有一个特性就是有连接的，例如电话一样，需要有人接，所以这个accept就是监听有没有人接电话，没有的话就先进行阻塞（这里只是以电话举例，不是说电话就是这么搞的）

Socket在服务器这边，是由accept返回的，在客户端这边，咱们代码里构造的时候制定了一个IP地址和端口号，有了这两个信息就能和服务器建立连接了。

既然是以字节的方式进行传输的，那就会涉及到IO文件操作 InputStream对应getInputStream方法和OutputStream对应的getOutputStream方法 进一步通过Socket对象，获取到内部的流对象，借助流对象来进行发送接收

3.2、TCP版本服务器

提示：这里需要我们自定义一个类叫做：TcpEchoServer来写TCP版本服务器的代码

第一步：就是创建一个ServerSocket 对象 创建一个构造方法进行传参一个具体的端口号

//相当于是  接收客户来
    private ServerSocket serverSocket=null;
    public  TcpEchoServer(int port) throws IOException {
        //传入一个端口号
        serverSocket =new ServerSocket(port);
    }

 第二步：那服务器ServerSocket对象已经创建好了，需要一个方法来进行服务器start方法

public void start() throws IOException {
        System.out.println("启动服务器");
        while(true){
            //使用这个 clientSocket 和 具体的的客户端进行交流
            //具体进行服务器  这里用作监听 客户端是否上线
            Socket clientSocket =serverSocket.accept();
            //如果上线  accept方法 阻塞结束 进行连接操作
            processConnection(clientSocket);
        }
    }

每次创建或者返回一个 Socket对象 ，（Socket就是文件）每次创建一个clientSocket对象，就要占用一个文件描述符表，使用完毕之后就会进行“释放” ，但是不建议直接在这里“释放”，在finally里面“释放”

到了这里就会友友问 ：ServerSocket 与Socket都是创建对象这不是多此一举吗？答案：这里其实我也不知道（凡是存在必有道理），我们先按照这样的方法来。

但是这里还是要说一下，这里该如何理解。

 第三步：processConnection如何来连接客户端操作

思路：

（1）可以显示一下 因为已经接收到了客户端 ，那这里打印一次客户端已上线

（2）Socket返回套接字输入流，返回套接字输出流，因为TCP是流式操作的

（3）处理肯定不是一个请求和响应所以需要循环操作，之后读取请求，判断请求数据是否存在，不存在那连接也就断开了 ，如果存在跳过即可，进行数据输入

（4）根据请求构造响应

（5）这里返回响应结果想要是一个字符串，但是接收来的是字节流 需要 稍作转换，转换成字符串

 （6）服务器打印

 以下是附上processConnection代码

 private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线！ \n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //基于上述socket 对象和 客户端 进行通信
        //以下使用 try（） 是java语法 try with resources
        try (InputStream inputStream=clientSocket.getInputStream();
             OutputStream outputStream=clientSocket.getOutputStream()){
            //由于要处理多个请求和 响应 也是使用 循环进行的
            while(true){
                //1、读取请求
                Scanner scanner=new Scanner(inputStream);
                if(!scanner.hasNext()){
                    System.out.printf("[%s:%d]客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                //注意 ！此处使用next 是一直 读取到换行符 或者 空格 或者 其他空白字符tab 但是 最终返回结果里不包含前面提到的这几个类别
                String request=scanner.next();
                //2、根据请求构造响应
                String response=process(request);
                //3、返回响应结果
                //OutputStream 没有write String功能 这里需要转换 可以把String 里的字节数组转换出来 进行写入
                //也可以用字符流来转化一下
                PrintWriter printWriter=new PrintWriter(outputStream);
                //此处使用 println来写入 让结果带有一个 \n 换行 方便对端来接收解析
                printWriter.println(response);
                //前面IO文件操作 中知道在字符写文件的时候 是需要刷新的所以这里也会进行
                printWriter.flush();

                System.out.printf("[%s:%d] req:%s ,resp :%s \n",clientSocket.getInetAddress().toString(),clientSocket.getPort()
                ,request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                //此处需要处理一下
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
 public String process(String request) { //这里也只是走个过程，并没有真的对请求进行处理
        return request;
    }

 main方法操作：

 3.3、TCP版本的客户端

提示：自定义一个TCPEchoClient类 以下TCP客户端代码都在该类中 

如果友友们，从前面看到这里了，基本不管是创建服务器还是创建一个客户端都是创建Socket对象，TCP客户端代码就没有TCP服务器代码麻烦了。

（1）创建Socket对象 写一个构造方法接收服务器的IP地址和 端口号

//定义一个Socket对象用来接收 IP地址和 端口号
    private Socket socket=null;

    public TcpEchoClient(String serverIp ,int serverPort) throws IOException {
        //Socket构造方法 能够识别点分十进制格式的 IP地址 比DatagramPacket更方便
        //new 这个对象的同时 就会进行TCP连接操作
        socket=new Socket(serverIp,serverPort);
    }

（2）写一个客户端启动start方法

客户端:用户写入数据、接收套接字输入流和输出流、连接结束的判断 、数据发送、接收数据

此处就不在详细解释了，基本和以上代码相似，代码配有详细的注释

public void start(){
        System.out.println("客户端启动");
        Scanner scanner=new Scanner(System.in);
        //接收套接字的输入流 和 输出流
        try(InputStream inputStream=socket.getInputStream();
            OutputStream outputStream=socket.getOutputStream()){
            while(true){
                System.out.println(">");
                //1. 先从键盘上读取用户数据内容
                String request=scanner.next();
                //判定输入一个算是解除连接  我们这里给了一个exit 表示结束连接 就相当于是 挂电话的按键
                if(request.equals("exit")){
                    System.out.println("goodbye");
                    break;
                }
                //2 把读到的内容构造请求发送给服务器  这里和TCP服务器是一样的 都需要进行转换将字节转化为字符串
                PrintWriter printWriter=new PrintWriter(outputStream);
                //发送给服务器 printWriter 的 println方法本身就会起到发送的作用
                printWriter.println(request);
                //此处需要刷新缓冲区 确保数据是发出去了，
                printWriter.flush();
                //3 服务器的响应    Scanner本身就参数就是字节输入流参数
                Scanner respScanner=new Scanner(inputStream);
                //进行读取
                String response=respScanner.next();
                //4 把响应内容显示到界面上
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

代码执行作以下分析：

以上代码是写完了，但是这里还有几个想要提醒要点

（1）疑惑：其中使用了printWriter类来转换字节流变成字符串是否还是同一个文件描述符表，OutputStream相当于一个文件描述符（socket文件）通过OutputStream就可以往这个 文件描述符表中写入数据，但是当前的OutputStream自身方法不方便 写字符串需要进行转换 ，PrintWriter对象来表示（对应的是同一个文件描述符表）

（2）以上能看发送是通过PrintWriter类中println方法进行发送的，细节问：如果不用println，直接用print发送行不行？？？

答案：不行（图解）

 3.4、TCP连接操作

 连接之后就发现问题了，不能多个客户端进行连接，如何解决呢？答案：多线程

3.4.1多线程TCP服务器

以前面的TCP服务器作为地基 这里有start方法内部需要稍作修改即可

 public void start() throws IOException {
        System.out.println("启动服务器");
        while(true){
            //使用这个 clientSocket 和 具体的的客户端进行交流
            //具体进行服务器  这里用作监听 客户端是否上线
            Socket clientSocket =serverSocket.accept();
            //如果上线  accept方法 阻塞结束 进行连接操作
            Thread thread=new Thread(()->{
                processConnection(clientSocket);
            });
            thread.start();
        }
    }

为什么多线程操作加在这里不用过多的解释，那多线程为什么不包含以下的代码呢

Socket clientSocket =serverSocket.accept();

 这里在while循环中，所以每次多线程执行并且在当前while循环中结束，再进行下一次while循环

 多线程已经能解决问题了，但这里还不打算演示，因为我们的客户端最多也就只能开几个，确实带的动，C10K（1w客户端）问题解决了，但是如果更多呢C10M（1kw客户端）问题呢，创建或者销毁这么多线程也是要有开销的，多线程提到开销问题优化措施就会想到线程池。

3.4.2、线程池TCP服务器

修改多线程修改代码位置相同

public void start() throws IOException {
        System.out.println("启动服务器");
        //创建线程池  这里创建的不是固定数量线程的池子， 是根据工作需要创建的线程池
        ExecutorService service=Executors.newCachedThreadPool();
        while(true){
            //使用这个 clientSocket 和 具体的的客户端进行交流
            //具体进行服务器  这里用作监听 客户端是否上线
            Socket clientSocket =serverSocket.accept();
            //如果上线  accept方法 阻塞结束 进行连接操作
            //提交任务
           service.submit(()->{
               processConnection(clientSocket);
           });
        }
    }

 这里就没有什么过多的解释了，如果对线程池不是很理解的友友（可以看下这篇博客）

现在演示，使用多线程之后，客户端有怎么样的结果

 注 ：TCP版本服务器和客户端没有写相关业务，友友们可以模仿这UDP翻译业务也给TCP写一个，基本是一样的写法，这里再TCP版本中就不在重复进行了。