TCP编写服务器，客户端以及遇到的两个问题，Socket，ServerScket 类，flush(),方法。以及多线程解决，及改进的线程池写法，IO多路复用的思想，C10K,C10M的阐述。万字超细-阿里云开发者社区

一、💛

TCP分量比UDP更重，协议更多，字节流，一个字节一个字节传输，一个TCP数据报就是一个字节数组，byte[]（也就是说不用整我们那个文件报）

主要分为两个类：

ServerSocket:给服务器使用的Socket。

Socket:既会给服务器用，也会给客户端使用

“连接”连接其实更准确的是说，服务器与客户端建立绑定关系，互相保存对方信息。

握手是系统的内核负责->一个服务器，要对应很多客户端，服务器内核里面有很多客户端连接->虽然内核中的连接很多，但是在应用程序中，还是要一个一个处理的～～

内核中的“连接”就像一个一个的“待办事项”，这些待办事项在一个队列数据结构中，应用程序就需要一个一个完成这些任务～～

要完成任务，也就需要先取任务：

serverSocket.accept()。->用户执行accept的时候，此时客户端还没来呢，所以会进行阻塞，直到有客户端连接成功为止。

二、 💙

把内核中的连接获取到应用程序，过程类似于“生产者，消费者模型”

客户端和服务器建立连接的时候，服务器就会和用户（客户端）进行一系列的数据交互，成为“握手”，这个过程建立完成了之后，连接就建立完成了，此时一个连接就会产生一个元素，消费的时候取出元素，放到应用程序里面处理，这也就构成了生产者，消费者模型

三、💜

一次IO操作，主要分为两个部分：

1.等（阻塞）

2.拷贝数据

介绍部分服务器核心代码

//accept是把内核中已经建立好的连接，给拿到应用程序中，
//但是这里的返回值并非是一个Connection这样的对象，
//而只是一个Socket对象，后续是Socket进行操作，换句话说：你要买房
//这个accept()相当于路边的销售小哥，给你拉进屋子不管你了，
//那个金牌销售小姐姐（Socket)给你服务
Socket clientSocket=serverSocket.accept();

1.Socket对象，相当于一个耳麦，可以对他说话，也可以听到声音，通过Socket对象和对方通信～，不用管对方到底是什么人，冲这个耳麦说话就行。

//inputStream相当于一个耳机，用来接收信息
//outputStream相当于一个麦克风，用来输出信息
try(InputStream inputStream=clientSocket.getInputStream();
OutputStream outputStream=clientSocket.getOutputStream()){····}

2.String request=scanner.next();

next是读取数据，一直读到空白符号才结束

空白符包括但不限于：换行（\n让光标另起一行），回车(\r让光标回到行首)，空格，制表符，翻页符，垂直制表符

3.flush()

PrintWrite writer=new PrintWriter(outputStream);
//flush()刷新的意思，就相当于冲马桶，一下子全下去了
writer.flush()

IO 操作是比较有开销的，可用于访问内存，进行IO次数越多，程序速度越慢，使用一块内存作为缓存区，写数据的时候，先到缓冲区里，攒一波数据，统一进行IO，PrintWriter内置了缓冲区，所以手动刷新，确保这里的数据真正的全部通过网卡发出去了，而不是残留在内存缓冲中的（瞬间有味道了哈哈哈💨💨💨）

加flush()属于是确保稳定性，不加也不一定出错，缓存区内置了一定的刷新策略～比如缓冲区满了，就会触发刷新，再比如程序退出，也会触发刷新，推荐大家加上flush()

4.

🐷全缓冲：（往网课/文件里面写），一般是全缓冲，不会收到ln的影响

🐷行缓冲：（特殊情况，换行会刷新）一般在标准输入输出这里～（往控制台打印），控制台中，用户输入一条指令，都是用enter按钮进行确认的，enter本质是\n(Linux中），\r\n(windows)

5.

这个代码暗含一个约定，客户端发来的请求，得到的文本数据，同时还得是带有空白符号进行分隔（比如换行）

String request = scanner.next();是什么意思呢，代码演示一下，也就是这样，我们正常输入I love you 连一起的输入，他会当成是我们先发一个I，然后进行回车，再发送love,再回车，返回你love,你再发送you，返回你you

四、❤️

具体实现服务器，底下的只是大部分的实现逻辑，现在，会不会有小可爱们看出哪里有问题呢

import sun.nio.ch.sctp.SctpNet;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
//建立一个ServerSocket对象，构造方法去设置他的端口号
    private ServerSocket serverSocket=null;
    public TcpEchoServer(int port) throws IOException{
        serverSocket=new ServerSocket(port);
    }
    public void  start() throws IOException {
        System.out.println("服务器启动");
        while (true){
//会停在这里，知道客户端上线，
            Socket clientSocket=serverSocket.accept();
//具体的操作方法写到这个方法之中
            processConnection(clientSocket);
        }
    }
    private void processConnection(Socket clientSocket) throws IOException {
//getInetAddress()是获取当前与Socket对象关联的InetAddress对象的字符串表示，在Socket类中getInetAddress()方法返回与（Socket)连接的远程对象，调用完这个方法之后，可以进一步调用toString()方法来获取改InetAddress对象的字符串表示。
//getPort()是返回与Socket连接的远程端口号。
        System.out.printf("[%s:%d] 客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //接下来就可以读取请求，根据请求计算响应，返回响应，然后进行老三步
        //Socket对象内部包含了两个字节流对象，可以把这俩字节流获取到，完成后，续写读写操作。
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream()) {
            //一次连接中，可能涉及到多次请求/响应
            while (true) {
                //1.读取请求并且解析，为了读取方便，使用Scanner
                Scanner scanner = new Scanner(inputStream);
//在客户端，没有发送请求的时候，也会进行阻塞，一直会阻塞到客户端真正发送了数据，或者客户端退出，hasNext()就返回了。
                if (!scanner.hasNext()) {
                    //1.读取完毕，客户端下线
                    System.out.printf("[%s:%d]客户端下线！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                //这个代码暗含一个约定，客户端发来的请求，得到的文本数据，同时还得是带有空白符号进行分隔（比如换行）
                String request = scanner.next();
                //2.根据请求计算响应
                String response = process(request);
                //3.把响应写回客户端，把OutputStream使用PrinterWriter包裹一下，方便进行发数据
                PrintWriter writer = new PrintWriter(outputStream);
                //使用PrintWriter的println方法，把响应返回给客户端。
                //此处用println，而不是print就是为了在结尾加上\n，方便客户端读取响应，用Scanner.next()读取
                writer.println(response);
                //这里还需要加上"刷新缓冲区操作"
                writer.flush();
                //日志，打印当前的请求详情
//getInetAddress()是获取当前与Socket对象关联的InetAddress对象的字符串表示，在Socket类中getInetAddress()方法返回与（Socket)连接的远程对象，调用完这个方法之后，可以进一步调用toString()方法来获取改InetAddress对象的字符串表示。request表示你的请求，response表示返回服务器的请求 
                System.out.printf("[%s:%d] req:%s,resp:%s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(), request, response);
            }
        }
    }
    public String process(String request){
        return  request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer=new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

好了我要公布答案了哦——

没错就是我们的关闭操作，因为Socket对象持有的文件描述符和之前那个一样，是需要关闭的，如果不关闭，就会这个文件描述符一直保持打开，关闭Socket对象的主要原因——避免资源泄露和过度占用。（带走你的年终奖大法）下面是改正

import sun.nio.ch.sctp.SctpNet;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
    private ServerSocket serverSocket=null;
    public TcpEchoServer(int port) throws IOException{
        serverSocket=new ServerSocket(port);
    }
    public void  start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket=serverSocket.accept();
            processConnection(clientSocket);
        }
    }
    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //接下来就可以读取请求，根据请求计算响应，返回响应，然后进行老三步
        //Socket对象内部包含了两个字节流对象，可以把这俩字节流获取到，完成后，续写读写操作。
        try(InputStream inputStream=clientSocket.getInputStream();
            OutputStream outputStream=clientSocket.getOutputStream()) {
            //一次连接中，可能涉及到多次请求/响应
            while (true) {
                //1.读取请求并且解析，为了读取方便，使用Scanner
                Scanner scanner = new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    //1.读取完毕，客户端下线
                    System.out.printf("[%s:%d]客户端下线！\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                //这个代码暗含一个约定，客户端发来的请求，得到的文本数据，同时还得是带有空白符号进行分隔（比如换行）
                String request = scanner.next();
                //2.根据请求计算响应
                String response = process(request);
                //3.把响应写回客户端，把OutputStream使用PrinterWriter包裹一下，方便进行发数据
                PrintWriter writer = new PrintWriter(outputStream);
                //使用PrintWriter的println方法，把响应返回给客户端。
                //此处用println，而不是print就是为了在结尾加上\n，方便客户端读取响应，用Scanner.next()读取
                writer.println(response);
                //这里还需要加上"刷新缓冲区操作"
                writer.flush();
                //日志，打印当前的请求详情
                System.out.printf("[%s:%d] req:%s,resp:%s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(), request, response);
            }
            }
        catch (IOException e){
            e.printStackTrace();
        }finally {
            //在finally中加上close操作，确保当前socket被及时关闭
            clientSocket.close();
        }
    }
    public String process(String request){
        return  request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer=new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

五、💚

下面来几个问题理解一手

当服务器接收到客户端的请求并对其进行处理后，可以通过获取一个PrintWriter对象，并使用它的print或者println方法将响应文本写入输出流。该输出流最终会传输到客户端，客户端可以读取并处理这些响应程序

🐣🐣客户端和服务器的inputStream和OutputStream是四个文件在接收传输数据吗？

答：准确的说是四个流对象，实际上是两个流对象。，通常情况下，是一个流对应一个文件的，这里是一个socket对象（文件）对应两个流对象。

写到try()里面是能自动关闭的，但是try{}这个里面就需要手动关闭，try with resources语法。

🐔🐔Scanner和PrintWriter是否进行close()呢，会不会有文件资源泄露呢？——不会！

流对象持有的资源，分为两个部分

1.内存（对象销毁，内存就回收了）

while循环一圈，内存自然销毁，scanner和printWriter没有文件描述符，持有的是inputStream,OutputStream引用（我们用try()已经关闭了）更准确的说持有文件描述符的是Socket对象。

2.文件描述符

六、 💖

具体去实现客户端代码

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
//这个new操作完成之后，就完成了tcp连接的建立
        socket = new Socket(serverIp, serverPort);
    }
    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scannerConsole = new Scanner(System.in);
//Socket对象内部包含两个内部字节流对象，可以把这两个字节流获取到，完成后续的读写操作。
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            while (true) {
                //1.从控制台输入字符串
                System.out.println("->");
//所有的next()的意思，都是一个空格，一个空格或者回车的这么读，比如你输入
//I love you ,他就会先输出I，在love 再you，他不会你再次输入，而是读取整个后存起来，一个一个一个读
                String request = scannerConsole.next();
                //2.把请求发送给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                //使用println带上换行，后续服务器读取请求，就可以用scanner.next来获取
                printWriter.println(request);
                printWriter.flush();
                //3.从服务器读取响应，也就是读取返回值
                Scanner scannerNetWork = new Scanner(inputStream);
//注意这里的next()的意思是，一块一块打印，而不是一整块打印，所以也需要while
                String response = scannerNetWork.next();
                //4.把响应打印出来
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient client=new TcpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

但是他这样也有问题,当我们选择再开一个客户端的时候，发生了问题，第一个客户端好用，但是第二个客户端陷入阻塞，此时我关闭第一个客户端，第二个客户端变成第一个客户端，他又好使了。

这就说明我们的代码出现了bug，发现是我们的代码结构出现了问题。

//服务器的代码中你接收到一个客户端的请求，那么此时线程进行这个方法中，
//那么你这个线程方法还没有结束，我们的第二个客户端该怎么启动呢，
//你买房，那个销售小哥，给你拉过来，再给你讲房子如何如何，那么第二个客人该怎么拉过来呢？
 public void  start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket=serverSocket.accept();
            processConnection(clientSocket);
        }
    }

此时破局之道在哪呢——看我那个比喻是不是感觉人像是不够用，感觉来个销售的小姐姐，那不是美滋滋 💖 💖 💖，这就需要用到我们之前的多线程了,这样两个客户端的问题就解决了。

//只需要改动服务器的这里就行，但是你也看到了这里
//我们进行频繁的创建线程。会造成一个资源的占用。
 public void  start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket=serverSocket.accept();
            Thread t=new Thread(()->{
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }

所以改进方法：使用我们的线程池

public class TcpEchoServer {
    private ServerSocket serverSocket=null;
//注意这里的线程池，不应该创建固定的数目
    private ExecutorService service= Executors.newCachedThreadPool();
    public TcpEchoServer(int port) throws IOException{
        serverSocket=new ServerSocket(port);
    }
    public void  start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket=serverSocket.accept();
            //使用线程池创建问题
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

这时候我们来想一下第一个问题：关闭的问题，我在使用的时候用 try with resources OK不？

//此时这么写这个代码有错误，processConnection和主线程是不同的线程了
//此时你这么写，在执行processCOnnection过程中，主线程try 就执行完毕了.
//这就会导致，clientSocket还没用完，我就先关闭了
//因此要把clientSocket交给ProcessConnection关闭
 try(Socket clientSocket=serverSocket.accept()){
            //使用线程池创建问题
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
}

虽然这里使用线程，避免了频繁的创建线程，但毕竟每个客户端对应一个线程，如果服务器对应客户端很多，服务器就要创建出大量的线程，同时对服务器开销很大。

当客户端进一步增加的时候，线程数目进一步增加，系统负担越来越重，响应速度也会大打折扣。

七、⭐️

是否有办法，使用一个线程，高效处理很多客户端的并发（几万个那种）->（真正意义的高并发）

C10K:同一时刻有10k个客户端（即1w个），通过前面的一些手段和各种硬件设备，可以处理线程池类。

C10M：同时刻，有1kw的客户端并发（如某某🦌恋情），引入了很多的技术手段，其中一个必要手段之一，IO多路复用/IO多路转接（四个大字核心）

开源：引入更多的硬件设备

节流：提高单位硬件资源能够处理的请求数目。

IO多路复用——属于节流方式

例如：一家人不同的口味饺子，包子，凉皮～～（人生不能缺少凉皮🌚🌚🌚）

我自己买，然后去别的地方买，然后再买，然后再等待，看哪个好，一起拎回去。

但是也可以同时出动一家人，他们三个去买，然后一起回来，这个相当于用了三个线程，可实际上，我一个线程不会比这三个线程慢多少。——操作系统提供的API，可搭配TCP，UDP API配合使用。

TCP编写服务器，客户端以及遇到的两个问题，Socket，ServerScket 类，flush(),方法。以及多线程解决，及改进的线程池写法，IO多路复用的思想，C10K,C10M的阐述。万字超细

热门文章

最新文章

相关课程

相关电子书

相关实验场景