TCP与UDP网络编程

已于 2024-07-18 10:03:36 修改
阅读量1k 收藏 12
点赞数 15
分类专栏： 网络编程 文章标签： 网络 tcp/ip udp
于 2024-07-17 21:18:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79890350/article/details/140487640
版权

网络通信协议

在这里插入图片描述

java.net 包中提供了两种常见的网络协议的支持:

  • UDP：用户数据报协议(User Datagram Protocol)
  • TCP：传输控制协议(Transmission Control Protocol)

TCP协议与UDP协议

TCP协议

  • TCP协议进行通信的两个应用进程：客户端、服务端
  • 使用TCP协议前，须先建立TCP连接，形成基于字节流的传输数据通道
  • 传输前，采用“三次握手”方式，点对点通信，是可靠的
    • TCP协议使用重发机制，当一个通信实体发送一个消息给另一个通信实体后，需要收到另一个通信实体确认信息，如果没有收到另一个通信实体确认信息，则会再次重复刚才发送的消息
  • 在连接中可进行大数据量的传输
    传输完毕，需释放已建立的连接，效率低

UDP协议

  • UDP协议进行通信的两个应用进程：发送端、接收端
  • 将数据、源、目的封装成数据包(传输的基本单位)，不需要建立连接
  • 发送不管对方是否准备好，接收方收到也不确认，不能保证数据的完整性，故是不可靠的
  • 每个数据报的大小限制在64K内
  • 发送数据结束时无需释放资源，开销小，通信效率高
  • 适用场景：音频、视频和普通数据的传输。例如视频会议

生活案例

TCP生活案例：打电话

UDP生活案例：发送短信、发电报

区别

  • TCP：可靠的连接(发送数据前，需要三次握手、四次挥手)，进行大数据量的传输，效率低。
  • UDP：不可靠的连接(发送前，不需要确认对方是否在)、使用数据报传输(限制在64kb以内)、效率高。

TCP协议

三次握手

TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
在这里插入图片描述
完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

四次挥手

TCP协议中，在发送数据结束后，释放连接时需要经过四次挥手。

  • 第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
  • 第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
  • 第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
  • 第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开。
    在这里插入图片描述

网络编程API

Socket类

基本介绍

在这里插入图片描述

在这里插入图片描述

示意图:

在这里插入图片描述

理解客户端、服务端

  • 客户端：

    • 自定义
    • 浏览器(browser — server)

  • 服务端：

    • 自定义
    • Tomcat服务器

TCP网络编程

通信模型

在这里插入图片描述

例题1

客户端发送内容给服务端，服务端将内容打印到控制台上。

public class TCPTest1 {

    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;

        try {
            // 1.创建一个Socket
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1"); //声明ip地址
            int port = 8989; //声明端口号
            socket = new Socket(inetAddress,port);

            // 2.发送数据
            os = socket.getOutputStream();
            os.write("你好，我是客户端，请多多关照".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 3.关闭socket、流
            try {
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null)
                    os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        Socket socket = null; //阻塞式方法
        InputStream is = null;
        try {
            // 1.创建一个ServerSocket
            int port = 8989;
            serverSocket = new ServerSocket(port);

            // 2.调用accept()，接收客户端的Socket
            socket = serverSocket.accept();
            System.out.println("服务器端已开启");

            System.out.println("收到了来自于" + socket.getInetAddress().getHostAddress() + "的连接");

            // 3.接收数据
            is = socket.getInputStream();
            byte[] buffer = new byte[1024];
            ByteArrayOutputStream baos = new ByteArrayOutputStream(); //内部维护了一个byte[]
            int len;
            while ((len = is.read(buffer)) != -1) {
                // 错误的，可能会出现乱码
//                String str = new String(buffer,0,len);
//                System.out.println(str);

                //正确的
                baos.write(buffer,0,len);
            }

            System.out.println(baos.toString());

            System.out.println("\n数据接收完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关朗Socket、ServerSocket、流
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

例题2

客户端发送文件给服务端，服务端将文件保存在本地。

public class TCPTest2 {
    //客户端
    @Test
    public void client() {
        // 1.创建Socket
        // 指明对方（即为服务器）的ip地址和端口号
        Socket socket = null;
        FileInputStream fis = null;
        OutputStream os = null;
        try {
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            int port = 9090;
            socket = new Socket(inetAddress,port);

            // 2.创建File的实例、FileInputstream的实例
            File file = new File("huan.jpg");
            fis = new FileInputStream(file);

            // 3.通过Socket，获取输出流
            os = socket.getOutputStream();

            // 读写数据
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                os.write(buffer,0,len);
            }
            System.out.println("数据发送完毕");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.关闭Socket和相关的流
            try {
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            // 1.创建ServerSocket
            int port = 9090;
            serverSocket = new ServerSocket(port);

            // 2.接收来自于客户端的socket:accept()
            socket = serverSocket.accept();

            // 3.通过Socket获取一个输入流
            is = socket.getInputStream();

            // 4.创建File类的实例、File0utputstream的实例
            File file = new File("huan_copy.jpg");
            fos = new FileOutputStream(file);

            // 5.读写过程
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer,0,len);
            }

            System.out.println("数据接收完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 6.关闭相关的Socket和流
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

例题3

从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功"给客户端。并关闭相应的连接。

public class TCPTest3 {
    //客户端
    @Test
    public void client() {
        // 1.创建Socket
        // 指明对方（即为服务器）的ip地址和端口号
        Socket socket = null;
        FileInputStream fis = null;
        OutputStream os = null;
        ByteArrayOutputStream baos = null;
        InputStream is = null;
        try {
            InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
            int port = 9090;
            socket = new Socket(inetAddress, port);

            // 2.创建File的实例、FileInputstream的实例
            File file = new File("huan.jpg");
            fis = new FileInputStream(file);

            // 3.通过Socket，获取输出流
            os = socket.getOutputStream();

            // 4.读写数据
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("数据发送完毕");

            // 5.客户端表明不再继续发送数据
            socket.shutdownOutput();

            // 6.接收来自于服务器端的数据
            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[5];
            int len1;
            while ((len1 = is.read(buffer1)) != -1) {
                baos.write(buffer1, 0, len1);
            }
            System.out.println(baos.toString());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 7.关闭Socket和相关的流
            try {
                baos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //服务端
    @Test
    public void server() {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            // 1.创建ServerSocket
            int port = 9090;
            serverSocket = new ServerSocket(port);

            // 2.接收来自于客户端的socket:accept()
            socket = serverSocket.accept();

            // 3.通过Socket获取一个输入流
            is = socket.getInputStream();

            // 4.创建File类的实例、File0utputstream的实例
            File file = new File("huan_copy2.jpg");
            fos = new FileOutputStream(file);

            // 5.读写过程
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }

            // 6.服务端发送数据给客户端
            os = socket.getOutputStream();
            os.write("你的图片很漂亮，我接收到了".getBytes());

            System.out.println("数据接收完毕");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 7.关闭相关的Socket和流
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

【案例】聊天室

聊天室模型

在这里插入图片描述

服务器端

public class ChatSeverTest {
    //这个集合用来存储所有在线的客户端
    static ArrayList<Socket> online = new ArrayList<Socket>();

    public static void main(String[] args) throws IOException {
        //1、启动服务器，绑定端口号
        ServerSocket server = new ServerSocket(8989);

        //2、接收n多的客户端同时连接
        while (true) {
            Socket accept = server.accept();

            online.add(accept);//把新连接的客户端添加到online列表中

            MessageHandler mh = new MessageHandler(accept);
            mh.start();
        }
    }

    static class MessageHandler extends Thread {
        private Socket socket;
        private String ip;

        public MessageHandler(Socket socket) {
            super();
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                ip = socket.getInetAddress().getHostAddress();
                //插入：给其他客户端转发“我上线了”
                sendToOther(ip+"上线了");

                //(1)接收该客户端的发送的消息
                InputStream input = socket.getInputStream();
                InputStreamReader reader = new InputStreamReader(input);
                BufferedReader br = new BufferedReader(reader);

                String str;

                while ((str = br.readLine()) != null) {
                    //(2)给其他在线客户端转发
                    sendToOther(ip + ":" + str);
                }

                sendToOther(ip + "下线了");
            } catch (IOException e) {
                try {
                    sendToOther(ip + "掉线了");
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            } finally {
                //从在线人员中移除我
                online.remove(socket);
            }

        }

        //封装一个方法：给其他客户端转发xxx消息
        public void sendToOther(String message) throws IOException {
            //遍历所有的在线客户端，一一转发
            for (Socket on : online) {
                OutputStream every = on.getOutputStream();
                PrintStream ps = new PrintStream(every);

                ps.println(message);
            }
        }
    }
}

客户端

public class ChatClientTest {
    public static void main(String[] args) throws Exception {
        //1、连接服务器
        Socket socket = new Socket("127.0.0.1", 8989);

        //2、开启两个线程
        //(1)一个线程负责看别人聊，即接收服务器转发的消息
        Receive receive = new Receive(socket);
        receive.start();

        //(2)一个线程负责发送自己的话
        Send send = new Send(socket);
        send.start();

        send.join();//等我发送线程结束了，才结束整个程序

        socket.close();
    }
}

class Send extends Thread{
    private Socket socket;
    public Send(Socket socket) {
        super();
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            OutputStream outputStream = socket.getOutputStream();
            //按行打印
            PrintStream ps = new PrintStream(outputStream);
            Scanner input = new Scanner(System.in);

            //从键盘不断的输入自己的话，给服务器发送，由服务器给其他人转发
            while (true) {
                System.out.println("自己的话：");
                String str = input.nextLine();
                if ("bye".equals(str)) {
                    break;
                }
                ps.println(str);
            }

            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class Receive extends Thread{
    private Socket socket;
    public Receive(Socket socket) {
         super();
         this.socket = socket;
    }

    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            Scanner input = new Scanner(inputStream);

            while (input.hasNextLine()) {
                String line = input.nextLine();
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

UDP网络编程

通信模型

在这里插入图片描述

示例

public class UDPTest {
    
    //发送端
    @Test
    public void sender() throws Exception {
        //1.创建DatagramSocket的实例
        DatagramSocket ds = new DatagramSocket();

        //2、将数据、目的地的ip，目的地的端口号部封装在DatagramPacket数据报中
        InetAddress inetAddress = InetAddress.getByName("127.0.0.1");
        int port = 9090;
        byte[] bytes = "我是发送端".getBytes("utf-8");
        DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, inetAddress, port);

        //发送数据
        ds.send(packet);
        ds.close();
    }

    //接收端
    @Test
    public void receiver() throws IOException {
        //1.创建DatagramSocket的实例
        int port = 9090;
        DatagramSocket ds = new DatagramSocket(port);

        //2. 创建数据报的对象，用于接收发送端发送过来的数据
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        //3.接收数据
        ds.receive(packet);

        //4.获取数据，并打印到控制台上
        String str = new String(packet.getData(), 0, packet.getLength());
        System.out.println(str);

        ds.close();
    }
}
SHtop11
关注
专栏目录
QT TCP/UDP 网络编程
04-23
### QT TCP/UDP 网络编程：深入解析与实践 #### 一、TCP网络编程概览 在探讨QT框架下的TCP/UDP网络编程之前，我们先简要回顾一下TCP/IP模型中的传输层协议——TCP（Transmission Control Protocol，传输控制协议）...
java网络编程使用tcp、udp实现多用户对话
01-10
总之，Java网络编程使用TCP和UDP实现多用户对话，涉及到客户端与服务器的连接建立、数据传输、异常处理、多线程或异步编程、以及安全性等多个方面。通过学习和实践，可以掌握这些关键技术，为开发高效、稳定的网络...
TCP.UDp.rar_UDP高级编程_tcp.udp
09-21
UDP编程的重点在于如何在没有内置确认机制的情况下实现可靠的数据传输，例如通过自定义的序列号和确认机制。此外，UDP的多播功能允许一次性将数据发送到多个目的地，这对于广播和多用户应用非常有用。 在创建一个...
Linux网络编程-TCP&UDP测试工具.zip
12-08
TCP&UDP测试工具
TCPUDP网络编程测试
12-25
TCPUDP网络编程测试
Java-网络
2301_81543552的博客
09-14 718
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
4.网络编程
weixin_45476535的博客
09-14 523
程序注册端口：1024-49151。单个协议下，端口号不能冲突。公有端口0-1023。
使用堡垒机登录ftp服务报网络不可达错误
ajax_beijing_java的博客
09-14 225
解决方法：由于不想安装额外的服务在服务器上，于是想到使用sftp服务代替ftp服务，发现是可以使用的。22端口默认就是启动的，在堡垒机上加了sftp服务，再次连接服务器并使用filezila传输文件 ，文件可以正常传输。至此，问题得到解决。场景：开发同事想使用ftp传输服务，连接服务器时报网络不可达错误。排查发现，如果想使用ftp服务，需要在服务器上部署ftp服务，21端口才会存在，才可以访问该服务。
网络工程师学习笔记——网络互连与互联网
2301_77279557的博客
09-14 833
网络互连相关技术
WireShark分析localhost包
ngczx的博客
09-11 732
WireShark分析localhost包
【计算机网络 - 基础问题】每日 3 题（七）
Newin2020的博客
09-16 1080
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~📝推荐参考地址：https://www.xiaolincoding.com/（这个大佬的专栏非常有用！
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 4726
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
网络设备登录——《路由与交换技术》实验报告
最新发布
qq_63926306的博客
09-17 1165
1.通过console端口访问路由器；2.掌握计算机与路由器、交换机的连接方法；3.理解路由器和交换机在启动过程中输出信息的含义；4.掌握网络设备的基本文件管理。（1）实验设备名称和型号版本数量描述MSR36-201略PCWindows 71安装CRT软件Console 串口线——1略第5类UTP以太网连接线——1交叉线（2）实验拓扑图（实验环境）实验前请保证路由器(交换机)的所有配置已经清空。
iptables实现内外网ip转换
m0_67475830的博客
09-13 513
准备三台虚拟机。
C#使用TCP-S7协议读写西门子PLC(三)
ylq1045的专栏
09-11 875
这里我们进行封装读写西门子PLC的S7协议命令以及连接西门子PLC并两次握手 新建部分类文件SiemensS7ProtocolUtil.ReadWrite.cs 主要方法： 连接西门子PLC并发送两次握手。两次握手成功后，才真正连接到PLC public OperateResult ConnectPlcAndHandshake(SiemensPlcCategory siemensPlcCategory, IPEndPoint endPoint, int timeout = 3000) 生成一个写入字节数据
yolo自动化项目实例解析（一）日志格式输出、并发异步多线程、websocket、循环截图、yolo推理、3d寻路
默子昂
09-14 2176
如果收到的消息是 "是否回放中 真" 或 "是否回放中 假"，则设置 state.状态_是否回放中 为 True 或 False。如果消息以 "录制的脚本" 开头，那么它会提取脚本内容，并更新 state.录制_脚本文本 变量。它首先向客户端发送一条“连接成功”的消息，并将新连接的客户端添加到connected_clients列表中。接着，它进入一个无限循环，接收来自客户端的消息，并根据消息的不同类型更新一些状态变量。如果端口被占用，它会让用户输入一个新的端口号，并将这个新的端口号保存到配置文件中。
网络分析仪仪器校准要怎么进行检测？容易出现哪些误差？
2401_83476848的博客
09-12 409
误差修正是对已知校准标准的测量，这些测量值存储在分析仪的存储器之中，数据用于计算误差模型。系统误差是由矢量网络分析仪和测试设置之中的缺陷引起的，是重复性误差，并假设它不随时间变化。校准件的使用可以达到减少误差的目的。2.开关重复性误差：分析仪中用于切换源衰减器设置的机械式RF开关，有时当机械式RF开关被启动时，触点的闭合方式与上次启动时不同。通过仪器校准措施增强，消除反射测量之中的三个系统误差:指向性、源匹配、频率响应。:是由于仪器或测试系统仪器校准之后性能发生变化引起的，主要是温度变化引起的。
.[[BitCloud@cock.li]].wstop勒索病毒数据怎么处理|数据解密恢复
数据恢复研究℃
09-11 943
导言随着网络技术的不断发展，勒索病毒已经成为网络安全领域的一大威胁。其中，.[[]].wstop、[[BitCloud@cock.li]].wstop 、[[BaseData@airmail.cc]].wstop勒索病毒作为一种新型的恶意软件，以其复杂的加密技术和隐蔽的传播方式，给个人和企业带来了巨大的数据安全和经济损失风险。本文将详细介绍.[[
【计算机网络 - 基础问题】每日 3 题（五）
Newin2020的博客
09-15 699
在计算机网络中，端口是一种逻辑上的概念，用于标识不同的网络应用程序或服务。端口是一个 16 位的整数，其取值范围是 0 到 65535。端口的作用是在一台计算机上区分不同的网络通信进程或服务。可以把计算机比作一个大楼，IP 地址就像大楼的地址，而端口就像是大楼里不同房间的门牌号。当网络数据包到达计算机时，除了通过 IP 地址找到这台计算机，还需要通过端口号将数据包准确地交给对应的应用程序或服务进行处理。
TCP与UDP网络编程流程对比解析
"这篇文章除了比较TCP与UDP在网络编程中的差异，还提供了简单的TCP和UDP服务器及客户端程序流程的概述。" TCP与UDP是网络编程中的两种主要传输协议，它们各有特点，适用于不同的场景。 1. **TCP（Transmission ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值