《bug记录》在利用TCP协议创建【服务器-客户端交互程序】中出现的一些问题

已于 2022-08-06 16:11:44 修改
阅读量530 收藏 1
点赞数 1
分类专栏： 日常bug 文章标签： 服务器 bug 运维 java
于 2022-08-06 16:11:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61061381/article/details/126193709
版权

目录

一、bug描述

 二、问题分析

三、问题解决

🍑改过后的服务器代码

 🍑改过后的客户端代码：

四、进一步的改进

一、bug描述

 

今天在写上传交互程序中，当我把服务器和客户端成功启动后，在客户端输入请求指令的时候，出现了上述情况。

下面是服务器的代码

package network;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
        Socket clientSocket = serverSocket.accept();
        processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    }
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }

    }
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

客户端的代码：

package network;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    Socket socket = null;

    public TcpEchoClient() throws IOException {
        // 指定客户端要连接的服务器
        socket = new Socket("127.0.0.1", 8000);
        // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("当前是客户端，请输入请求");

        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
            // 对我们的读取和发送进行写包装，使得读取和包装更方便
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
            while (true) {
                System.out.print("> ");
                // 1、客户端从键盘输入请求
                String request = scanner.nextLine();
                // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
                // 2、把请求发送给服务器

                printWriter.write(request);
                // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
                // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
                printWriter.flush(); // 刷新缓冲区
                // 3、从服务器读取响应内容
                String response = scannerNet.nextLine();
                // 4、打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            socket.close();
        }
}
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        client.start();
    }
}

 

 二、问题分析

于是我打开java的工具包jconsole.exe查看相关的线程执行情况 

 ​​​​​​​

 

客户端相关代码： 

 

 

那么客户端在这里出现异常正常吗？很正常因为我们的服务器在正常情况下，当把响应发送给客户端后，是要打印日志的。但从我们上述的运行结果来看，我们的服务器并没有打印响应（这说明服务器没有成功的把响应发送给客户端，而是陷入了阻塞）

所以客户端在这里的阻塞是正常的

 对应的服务器代码：

 

 

那么我们在来看看服务器的代码究竟在哪里出现了问题：’

 

 对应的服务器代码： 

为什么会在scannerNet.nextLine()这里陷入阻塞呢？nextLine不是遇到回车就结束吗？我们在客户端输入请求后明明敲了一个回车呀！

 

 通过下面这个栗子我们可以发现一些问题：

 

那么如果这样的话， 我们服务器从客户端读取request的时候，接收到的数据也是没有换行符的——也就是说：

String request = scannerNet.nextLine();

 这一行的读取一直无法正常的结束，线程自然就陷入了阻塞当中。

 

三、问题解决

清楚了这一点就好办了，我们在下面的客户端代码中： 

 

 对应的服务器代码：

🍑改过后的服务器代码

package network;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
        Socket clientSocket = serverSocket.accept();
        processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    }
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }

    }
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

 

 🍑改过后的客户端代码：

package network;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    Socket socket = null;

    public TcpEchoClient() throws IOException {
        // 指定客户端要连接的服务器
        socket = new Socket("127.0.0.1", 8000);
        // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    }

    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("当前是客户端，请输入请求");

        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
            // 对我们的读取和发送进行写包装，使得读取和包装更方便
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
            while (true) {
                System.out.print("> ");
                // 1、客户端从键盘输入请求
                String request = scanner.nextLine();
                // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
                // 2、把请求发送给服务器

                printWriter.println(request);
                // printWriter.write(request);
                // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
                // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
                printWriter.flush(); // 刷新缓冲区
                // 3、从服务器读取响应内容
                String response = scannerNet.nextLine();
                // 4、打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            socket.close();
        }
}
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        client.start();
    }
}

 

测试案例

四、进一步的改进

 实现多线程服务器

package network;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        while (true) {
            // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
            // 如果当前没有客户端来建立连接, 就会阻塞等待!!
            Socket clientSocket = serverSocket.accept();
            // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
            // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
            // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
            Thread thread = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }

    }
    // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 falseSystem.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("[%s:%d]  request: %s, response: %s\n",
                        clientSocket.getInetAddress(), clientSocket.getPort(),
                        request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }

    }
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

 

 

通过线程池实现多线程服务器

package network;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        ExecutorService service = Executors.newCachedThreadPool();// 此处不太适合使用 "固定个数的"
        while (true) {
            // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
            // 如果当前没有客户端来建立连接, 就会阻塞等待!!
            Socket clientSocket = serverSocket.accept();
            // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务

            // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
            // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
//            Thread thread = new Thread(() -> {
//                try {
//                    processConnection(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            thread.start();

            // [版本3] 使用线程池, 来解决频繁创建销毁线程的问题.
            // 此处不太适合使用 "固定个数的"
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });

        }

    }
    // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("[%s:%d]  request: %s, response: %s\n",
                        clientSocket.getInetAddress(), clientSocket.getPort(),
                        request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }

    }
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

 

是小鱼儿哈
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
TCP编程常见问题
weixin_43606861的博客
03-05 435
1、网络字节序 大端字节序 2、TCP和UDP区别 UDP TCP 是否连接 无连接 面向连接 是否可靠 不可靠传输，不使用流量控制和拥塞控制 可靠传输，使用流量控制和拥塞控制 连接对象个数 支持一对一，一对多，多对一和多对多交互通信 只能是一对一通信 .
使用TcpListener的AcceptSocket()方法和AcceptTcpClient()方法接受远端数据时,程序总是好像死机一样!请问如何解决？
qirenli_cn的专栏
11-30 6520
为什么我在使用TcpListener的AcceptSocket()方法和AcceptTcpClient()方法接受远端数据时，程序总是好像死机一样。进行调试时关标停在AcceptSocket()方法或AcceptTcpClient()方法上就不动了，一直等到数据读入才向下继续执行。请问解决这种死机的现象应该怎么做？谢谢具体代码如下：/////////////////////////////////
TCP数据流传输遇到的问题
重剑无锋
06-05 2964
通过socket传输数据的时候遇到问题。模式：一服务器对多客户端；遇到的问题刚开始感觉有点奇怪，有时正确有时又出错，而且出错的场合也不可捉摸，大致测试了下，猜测过如下可能性：先是感觉群发可以，单点发送不行后来发现是有线网可以，无线网不行再发现是大数据不行，小数据包可以最后记录在发送端和接收端 数据传输的报文，发现问题是：在接收端时，TCP数据读取不完全时，就开始解析了，导致协议
服务器和客户端在C语言的怎么运行,为什么TCP服务器与客户端在同一台机器上运行时无法建立连接...
weixin_39603117的博客
05-22 238
服务端代码#include #include #include #include #include /* See NOTES */#include #include #define N 1024//./a.out ip portint main(int argc, const char *argv[]){char buf[1024] = {0};int listen_fd =...
坦白局，TCP粘包：我只是犯了每个数据包都会犯的错
m0_63437643的博客
01-03 71
事情从一个健身教练说起吧。​编辑切换为居中添加图片注释，不超过 140 字（可选）李东，自称亚健康终结者，尝试使用互联网+的模式拓展自己的业务。在某款新开发的聊天软件琛琛上发布广告。键盘说来就来。疯狂发送"李东"，回车发送！，"亚健康终结者"，再回车发送！​编辑添加图片注释，不超过 140 字（可选）还记得四层网络协议长什么样子吗？​编辑切换为居中添加图片注释，不超过 140 字（可选）
linux accept 队列,linux accept建立连接
weixin_42485489的博客
05-16 333
下面以一个不太精确却通俗易懂的图来说明之：研究过backlog含义的朋友都很容易理解上图。这两个队列是内核实现的，当服务器绑定、监听了某个端口后，这个端口的SYN队列和ACCEPT队列就建立好了。客户端使用connect向服务器发起TCP连接，当图中1.1步骤客户端的SYN包到达了服务器后，内核会把这一信息放到SYN队列(即未完成握手队列)中，同时回一个SYN+ACK包给客户端。一段时间后，在较中...
C#FTP服务器和客户端，没有bug，上传下载删除重命名，列表在listbox显示，有运行log信息，包括实验报告
01-09
在这个C#项目中，我们探讨了如何构建一个无bug的FTP服务器和客户端，这些功能涵盖了基本的文件操作以及用户交互。 首先，C# FTP服务器部分是基于.NET Framework或.NET Core构建的，它实现了FTP协议的标准命令集，如...
tcp客户端（多线程版本）
最新发布
04-25
在描述中提到的“存在很多bug，连接到服务器后，点击发送，在子线程中每1ms发送一次数据给服务器”，这表明该客户端程序可能在实现上存在问题。首先，过于频繁地每1毫秒发送一次数据可能导致过度占用网络带宽，增加...
qt实现tcp通信，客户端和服务端。TCP.zip
08-08
在QT中，我们可以使用QTcpSocket类来处理客户端的TCP通信，而使用QTcpServer类来处理服务器端的TCP通信。 对于服务端： 1. 创建QTcpServer对象，通过调用listen()函数启动监听特定端口。例如： ```cpp QTcpServer ...
C++笔试+UC浏览器笔试--客户端工程师，中间件工程师
05-14
在中间件工程师的角色中，他们通常负责连接客户端和服务器，处理数据交换，实现业务逻辑。因此，对TCP/IP协议栈的理解，多线程编程，以及异步编程模型（如回调、事件驱动或协程）的应用是非常重要的。中间件工程师还...
ManLiHyang-Server:ManLiHyang的服务器（主）应用程序
05-26
4. **日志记录**：为了方便调试和监控，服务器通常会记录操作日志，这有助于追踪问题和优化性能。 5. **异常处理**：良好的异常处理机制能够确保服务器在遇到错误时不会立即崩溃，而是优雅地处理异常并给出反馈。 ...
python的HttpServer出现socket.accept()阻塞卡死
Mage的专栏
11-04 9254
最近想用python做一个我微信公众号的后台，结果发现，服务器刚启动的一个多小时微信发的消息是有回复，但过几个小时之后，所有给服务器发现的请求都没有回复了，找了两天问题，昨晚上还弄半夜3点。总算把问题给解决了。服务器用的是下边这个类：class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):和一个处理http各种do_请求的Handler：class
排查 reactor-netty 报错 Connection reset by peer 的过程
热门推荐
谈谈1974
05-12 2万+
文章目录1. 报错现象2. 排查过程2.1 Connection reset by peer 的原因2.2 syscall:read(..) failed: Connection reset by peer 错误3. 最终原因 1. 报错现象 组内一个服务从 spring-webmvc 框架切换到 spring-webflux，在线上跑了一段时间后偶现如下错误 log 。log 中 L:/10.0.168.212:8805 代表了本地服务所在的服务器 IP 和 端口，R:/10.0.168.38:473
Socket编程-tcp服务端和客户端通信
~~
10-18 569
1.基于Tcp协议的Socket通讯类似于B/S架构，面向连接，但不同的是服务器端可以向客户端主动推送消息。 　　使用Tcp协议通讯需要具备以下几个条件： 　　　　(1).建立一个套接字(Socket) 　　　　(2).绑定服务器端IP地址及端口号--服务器端 　　　　(3).利用Listen()方法开启监听--服务器端 　　　　(4).利用Accept()方法尝试与客户端建立一个连接-...
TCP传输,数据受损,解决方案
A_super_C的博客
01-30 301
我选择的是json作为传输的数据格式，在传输文件时有客户端向服务端发起，服务端收到讯息后再发送一个状态响应给客户端，如果传输过程中数据丢失了，服务端就会解析失败，这时候返给客户端一个状态码，客户端收到状态码后就知道刚刚发给服务端的讯息有没有出现数据丢失导致不完整的情况。如果不完整，就重发刚刚的讯息，成功收到就继续发其它讯息。从前天到现在感觉传输文件时效果还不错。还没出现啥bug.如果你还有什么好的建议也可在评论区留言分享。
Apache JMeter TCPSampler的使用及自定义
一个测试工程师的代码世界
06-26 1万+
JMeter提供纯TCP协议级别Sampler，如果你不觉得麻烦可以通过它来完成所有基于TCP协议的性能测试，这样一个万金油式的Sampler由于很少进入使用者的视野，因此，在实际使用中存在着许多隐藏特性和误解，本篇将对TCP Sampler使用中的一些特点进行讲解。
（十五）TcpClient
qq_50538421的博客
09-05 757
-_-
用JavaSeverSocket和Socket实现的TCP服务器-客户端卡死的问题？
本人的技术和文笔有限，正在努力成长中，请各位朋友多多指正与包涵！
11-24 1182
** 在写一个简单的服务器-客户端Demo时，想使用效率更高的缓存字节流来接收从Socket获取的字节流，结果发现出了服务器和客户端卡死的问题** 【一开始是的思路是，缓存流用到了缓存机制，我没用flush刷新，是不是因为这样卡死在缓存里了。（思路错误，因为我是输入用的缓存流，输出根本用缓存流）】 tip1：如果本例中，在客户端发送完信息后，就调用os.close()把输入流关闭，是客户端是会报错java.net.SocketException: Socket is closed的，因为- 如果此Sco
ServerSocket 用法详解
Mr. David 专栏
11-19 2823
<br />在客户/服务器通信模式中，服务器端需要创建监听特定端口的ServerSocket，ServerSocket负责接收客户连接请求。本章首先介绍ServerSocket类的各个构造方法，以及成员方法的用法，接着介绍服务器如何用多线程来处理与多个客户的通信任务。<br />本章提供线程池的一种实现方式。线程池包括一个工作队列和若干工作线程。服务器程序向工作队列中加入与客户通信的任务，工作线程不断从工作队列中取出任务并执行它。本章还介绍了java.util.concurrent包中的线程池类的用法，在服
测试bug指程序出现报错，还是业务逻辑出现问题
04-01
如果程序在某个功能或场景下出现报错或异常，测试人员就需要记录并报告这个bug，以便开发人员及时修复。另一方面，如果程序的业务逻辑出现问题，也会被视为一个bug，因为这会影响程序的正确性和可靠性。因此，测试...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是小鱼儿哈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值