socket网络编程：UDP通信、TCP通信

最新推荐文章于 2024-07-30 20:50:47 发布
最新推荐文章于 2024-07-30 20:50:47 发布
阅读量629 收藏 5
点赞数
分类专栏： Linux网络编程 文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43690795/article/details/107746739
版权

本篇文章默认你对UDP协议和TCP协议已经理解掌握了：UDP协议详解、TCP协议详解

UDP网络通信编程

首先我们需要知道 UDP协议是传输层协议，面向数据报，无连接，不可靠传输，实时性高。
在这里插入图片描述

创建套接字：使进程与网卡之间建立联系

在这里插入图片描述
domain：地址域–>使用AF_INET(IPV4)
type：套接字类型
        SOCK_STREAM–流式套接字–默认对应的协议：TCP
        SOCK_DGRAM–数据报套接字–默认对应的协议：UDP
protocol：协议类型
        套接字类型默认协议–0
        IPPROTO_TCP–6
        IPPROTO_UDP–17
返回值：文件描述符–套接字操作句柄
在这里插入图片描述

为套接字绑定地址信息(ip/port)

在这里插入图片描述
sockfd：套接字操作句柄，socket函数的返回值
addr：地址类型(IPV4或者IPV6等等)
addrlen：地址信息长度
返回值：成功返回0，失败返回-1
在这里插入图片描述

客户端首先向服务端发送数据

服务端通常必须固定一个地址信息，不能随意改变；但是客户端的地址可以随意，因为数据发送给服务端，服务端就能获知客户端的地址。
在这里插入图片描述
sockfd：套接字操作句柄，socket函数的返回值
buf：要发送什么数据
len：数据的长度
flags：通常置0，阻塞操作(即缓冲区放满后等待)
dest_addr：接收端地址信息（ip+port）
addrlen：接收端地址信息长度
返回值：返回实际发送的数据长度，失败：-1
在这里插入图片描述

服务端接收数据

客户端发送的数据到达服务端主机后，服务端操作系统根据这个数据的地址信息，决定将这个数据放到哪一个套接字的缓冲区中(数据由指定进程处理)；服务端通过创建套接字返回的描述符，在内核中找到套接字结构体，进而从缓冲区中取出数据。
在这里插入图片描述
sockfd：套接字操作句柄，socket函数的返回值
buf：从接收缓冲区拿到的数据存在在哪里
len：接收buf定义的最大长度，预留\0的位置
flags：通常置0，阻塞操作(即缓冲区中没有数据时等待)
src_addr：发送端地址信息（ip+port）
addrlen：发送端地址信息长度
返回值：返回实际接收的数据长度，失败：-1
在这里插入图片描述

关闭套接字–>释放内核中套接字占据的资源

在这里插入图片描述
fd：套接字操作句柄，socket函数的返回值
在这里插入图片描述

模拟实现UDP网络通信

#pragma once 
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <iostream>
#include <string>

#define PORT 17777

class UdpSvr
{
    public:
        UdpSvr()
        {
            sock_ = -1;
        }

        ~UdpSvr()
        {}

        bool Create()
        {
            sock_ = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
            if(sock_ < 0)
            {
                std::cout << "Create failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Bind()
        {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(PORT);
            addr.sin_addr.s_addr = inet_addr("0.0.0.0");
            int ret = bind(sock_, (struct sockaddr*)&addr, sizeof(addr));
            if(ret < 0)
            {
                std::cout << "Bind failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Send(std::string& msg, struct sockaddr_in* peeraddr)
        {

            ssize_t send_size = sendto(sock_, msg.c_str(), msg.size(), 0, (struct sockaddr*)peeraddr, sizeof(struct sockaddr_in));
            if(send_size < 0)
            {
                std::cout << "Send failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Recv(std::string& msg, struct sockaddr_in* peeraddr)
        {
            char buf[1024] = {0};
            socklen_t peeraddr_len = sizeof(struct sockaddr_in);
            ssize_t recv_size = recvfrom(sock_, &buf, sizeof(buf) - 1, 0, (struct sockaddr*)peeraddr, &peeraddr_len);
            if(recv_size < 0)
            {
                std::cout << "Recv failed" << std::endl;
                return false;
            }
            msg.assign(buf, recv_size);
            return true;
        }

        void Close()
        {
            close(sock_);
            sock_ = -1;
        }
    private:
        int sock_;
};

#include "udpsvr.hpp"

int main()
{
    UdpSvr us;
    if(!us.Create())
    {
        return 0;
    }

    if(!us.Bind())
    {
        return 0;
    }

    while(1)
    {
        std::string msg;
        struct sockaddr_in cliaddr;
        if(!us.Recv(msg, &cliaddr))
        {
            continue;
        }
        std::cout << "client say:" << msg << std::endl;

        std::cout << "server say:";
        fflush(stdout);
        std::cin >> msg;
        if(!us.Send(msg, &cliaddr))
        {
            continue;
        }
    }
    us.Close();
    return 0;
}

#include "udpsvr.hpp"

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        std::cout << "./cli [ip]" << std::endl;
        return 0;
    }
    std::string ip = argv[1];

    UdpSvr us;
    if(!us.Create())
    {
        return 0;
    }

    struct sockaddr_in svraddr;
    svraddr.sin_family = AF_INET;
    svraddr.sin_port = htons(PORT);
    svraddr.sin_addr.s_addr = inet_addr(ip.c_str());

    while(1)
    {
        std::string msg;
        std::cout << "client say:";
        fflush(stdout);
        std::cin >> msg;
        if(!us.Send(msg, &svraddr))
        {
            continue;
        }

        if(!us.Recv(msg, &svraddr))
        {
            continue;
        }
        std::cout << "server say:" << msg << std::endl;
    }
    us.Close();
    return 0;
}

TCP网络通信编程

首先我们需要知道 TCP协议是传输层协议，面向字节流，面向连接，可靠传输，安全性高。
在这里插入图片描述

创建套接字：使进程与网卡之间建立联系

在这里插入图片描述
domain：地址域–>使用AF_INET(IPV4)
type：套接字类型
        SOCK_STREAM–流式套接字–默认对应的协议：TCP
        SOCK_DGRAM–数据报套接字–默认对应的协议：UDP
protocol：协议类型
        套接字类型默认协议–0
        IPPROTO_TCP–6
        IPPROTO_UDP–17
返回值：文件描述符–套接字操作句柄
在这里插入图片描述

为套接字绑定地址信息(ip/port)

在这里插入图片描述
sockfd：套接字操作句柄，socket函数的返回值
addr：地址类型(IPV4或者IPV6等等)
addrlen：地址信息长度
返回值：成功返回0，失败返回-1
在这里插入图片描述

客户端流程
1、创建套接字：使进程与网卡之间建立联系
2、为套接字绑定地址信息(ip/port)
3、向服务端发起连接请求

在这里插入图片描述
sockfd：套接字描述符
addr：服务端的地址信息(当前客户端需要连接哪一个服务端的地址信息)
addrlen：地址信息长度
在这里插入图片描述

4、发送数据

在这里插入图片描述
sockfd：accept函数返回的操作系统内核新创建的socket操作句柄
buf：要给对端发送什么数据
len：发送数据的长度
flags：默认置 0–>阻塞发送
在这里插入图片描述

5、接收数据

在这里插入图片描述
sockfd：accept函数返回的操作系统内核新创建的socket操作句柄
buf：从接收缓冲区接收的数据放到哪里去
len：最大能放多少
flags：
        0：阻塞发送
        MSG_PEEK：探测接收，即不会将接收缓冲区当中的数据移除，而是拷贝接收缓冲区的数据(接收缓冲区当中原有的数据依然存在)
在这里插入图片描述

6、关闭套接字–>释放内核中套接字占据的资源

在这里插入图片描述
fd：套接字操作句柄，socket函数的返回值
在这里插入图片描述

服务端流程
1、创建套接字：使进程与网卡之间建立联系
2、为套接字绑定地址信息(ip/port)
3、监听

在这里插入图片描述
sockfd：监听套接字的操作句柄
backlog：已完成连接队列的大小
        同一时刻，服务端最大的并发连接数
        监听的时候，一旦有新的连接到来，OS会对新的连接分配一个socket，进行一对一服务。
在这里插入图片描述
在这里插入图片描述

4、获取连接

在这里插入图片描述
sockfd:监听套接字的操作句柄
addr:客户端地址信息
addrlen:客户端地址信息的长度，输入输出型参数
返回值：返回的是操作系统内核创建的新的socket的文件描述符
在这里插入图片描述

5、接收数据
6、发送数据
7、关闭套接字–>释放内核中套接字占据的资源

模拟实现TCP网络通信

Tcp通信时必须使用多进程或者多线程：因为accept会阻塞

对于单个执行流而言，由于代码是串行运行的

  1. 将accept函数放到while(1)循环当中
    每次循环要往下继续执行，则必须有一个新的连接到来，并且在往下执行的时候，是和新的客户端沟通
  2. 将accept函数放到while(1)循环外面
    则整个服务器只能和一个客户端进行业务的收发数据，但是并不能代表不能和服务器建立连接，以为TCP的三次握手是在listen阶段，告诉操作系统可以监听，连接的建立右操作系统完成，完成后的连接放到已完成连接队列当中去。
多进程
#pragma once 
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <iostream>

#define PORT 17778

class TcpSvr
{
    public:
        TcpSvr()
        {
            sock_ = -1;
        }

        ~TcpSvr()
        {}

        bool CreateSock()
        {
            sock_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if(sock_ < 0)
            {
                std::cout << "Create failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Bind()
        {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(PORT);
            addr.sin_addr.s_addr = inet_addr("0.0.0.0");
            int ret = bind(sock_, (struct sockaddr*)&addr, sizeof(addr));
            if(ret < 0)
            {
                std::cout << "Bind failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Listen(int backlog = 5)
        {
            int ret = listen(sock_, backlog);
            if(ret < 0)
            {
                std::cout << "Listen failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Accept(TcpSvr& ts, struct sockaddr_in* addr = NULL)
        {
            struct sockaddr_in cliaddr;
            socklen_t cliaddr_len = sizeof(cliaddr);
            int newsock = accept(sock_, (struct sockaddr*)&cliaddr, &cliaddr_len);
            if(newsock < 0)
            {
                std::cout << "Accept failed" << std::endl;
                return false;
            }
            ts.sock_ = newsock;

            if(addr != NULL)
            {
                memcpy(addr, &cliaddr, cliaddr_len);
            }
            return true;
        }

        bool Connect(struct sockaddr_in* svraddr)
        {
            int ret = connect(sock_, (struct sockaddr*)svraddr, sizeof(struct sockaddr_in));
            if(ret < 0)
            {
                std::cout << "Connect failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Send(std::string& msg)
        {
           ssize_t send_size = send(sock_, msg.c_str(), msg.size(), 0);
           if(send_size < 0)
           {
                std::cout << "Send failed" << std::endl;
                return false;
           }
           return true;
        }

        bool Recv(std::string& msg)
        {
            char buf[1024] = {0};
            ssize_t recv_size = recv(sock_, buf, sizeof(buf) - 1, 0);
            if(recv_size < 0)
            {
                std::cout << "Recv failed" << std::endl;
                return false;
            }
            else if(recv_size == 0)
            {
                std::cout << "Peer close connect" << std::endl;
                return false;
            }
            msg.assign(buf, recv_size);
            return true;
        }

        void Close()
        {
            close(sock_);
            sock_ = -1;
        }
    private:
        int sock_;
};

#include "tcpsvr.hpp"
#include <signal.h>
#include <sys/wait.h>
#include <stdlib.h>

void sigcb(int signo)
{
    //等待子进程
    (void)signo;
    while(1)
    {
        waitpid(-1, NULL, WNOHANG);
    }
}

int main()
{
    signal(SIGCHLD, sigcb); 

    TcpSvr ts;
    if(!ts.CreateSock())
    {
        return 0;
    }

    if(!ts.Bind())
    {
        return 0;
    }

    if(!ts.Listen())
    {
        return 0;
    }


    while(1)
    {
        TcpSvr ts2;
        struct sockaddr_in cliaddr;
        if(!ts.Accept(ts2, &cliaddr))
        {
            continue;
        }
        std::cout << "Server have a new connect, " << inet_ntoa(cliaddr.sin_addr) << ":" << ntohs(cliaddr.sin_port) << std::endl; 
        
        int pid = fork();
        if(pid < 0)
        {
            std::cout << "Create fork failed" << std::endl;
            exit(1);
        }
        else if(pid == 0)
        {
            //child
            while(1)
            {
                std::string msg;
                if(!ts2.Recv(msg))
                {
                    break;
                }
                std::cout << "cilent say:" << msg << std::endl;

                std::cout << "server say:";
                fflush(stdout);
                std::cin >> msg;
                ts2.Send(msg);
            }
            ts2.Close();
            exit(1);
        }
        else 
        {
            //father
            ts2.Close();
        }
    }

    ts.Close();
    return 0;
}

#include "tcpsvr.hpp"

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        std::cout << "./cli [ip]" << std::endl;
        return 0;
    }
    std::string ip = argv[1];

    TcpSvr ts;
    if(!ts.CreateSock())
    {
        return 0;
    }

    struct sockaddr_in svraddr;
    svraddr.sin_family = AF_INET;
    svraddr.sin_port = htons(PORT);
    svraddr.sin_addr.s_addr = inet_addr(ip.c_str());
    if(!ts.Connect(&svraddr))
    {
        return 0;
    }

    while(1)
    {
        std::string msg;
        std::cout << "client say:";
        fflush(stdout);
        std::cin >> msg;
        ts.Send(msg);

        ts.Recv(msg);
        std::cout << "server say:" << msg << std::endl;
    }

    ts.Close();
    return 0;
}
多线程
#pragma once 
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <iostream>

#define PORT 17778

class TcpSvr
{
    public:
        TcpSvr()
        {
            sock_ = -1;
        }

        ~TcpSvr()
        {}

        bool CreateSock()
        {
            sock_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if(sock_ < 0)
            {
                std::cout << "Create failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Bind()
        {
            struct sockaddr_in addr;
            addr.sin_family = AF_INET;
            addr.sin_port = htons(PORT);
            addr.sin_addr.s_addr = inet_addr("0.0.0.0");
            int ret = bind(sock_, (struct sockaddr*)&addr, sizeof(addr));
            if(ret < 0)
            {
                std::cout << "Bind failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Listen(int backlog = 5)
        {
            int ret = listen(sock_, backlog);
            if(ret < 0)
            {
                std::cout << "Listen failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Accept(TcpSvr* ts, struct sockaddr_in* addr = NULL)
        {
            struct sockaddr_in cliaddr;
            socklen_t cliaddr_len = sizeof(cliaddr);
            int newsock = accept(sock_, (struct sockaddr*)&cliaddr, &cliaddr_len);
            if(newsock < 0)
            {
                std::cout << "Accept failed" << std::endl;
                return false;
            }
            ts->sock_ = newsock;

            if(addr != NULL)
            {
                memcpy(addr, &cliaddr, cliaddr_len);
            }
            return true;
        }

        bool Connect(struct sockaddr_in* svraddr)
        {
            int ret = connect(sock_, (struct sockaddr*)svraddr, sizeof(struct sockaddr_in));
            if(ret < 0)
            {
                std::cout << "Connect failed" << std::endl;
                return false;
            }
            return true;
        }

        bool Send(std::string& msg)
        {
           ssize_t send_size = send(sock_, msg.c_str(), msg.size(), 0);
           if(send_size < 0)
           {
                std::cout << "Send failed" << std::endl;
                return false;
           }
           return true;
        }

        bool Recv(std::string& msg)
        {
            char buf[1024] = {0};
            ssize_t recv_size = recv(sock_, buf, sizeof(buf) - 1, 0);
            if(recv_size < 0)
            {
                std::cout << "Recv failed" << std::endl;
                return false;
            }
            else if(recv_size == 0)
            {
                std::cout << "Peer close connect" << std::endl;
                return false;
            }
            msg.assign(buf, recv_size);
            return true;
        }

        void Close()
        {
            close(sock_);
            sock_ = -1;
        }
    private:
        int sock_;
};

#include "tcpsvr.hpp"

void* ThreadStart(void* arg)
{
    pthread_detach(pthread_self());
    TcpSvr* ts = (TcpSvr*)arg;
    while(1)
    {
        std::string msg;
        ts->Recv(msg);
        std::cout << "client say:" << msg << std::endl;

        std::cout << "server say:";
        fflush(stdout);
        std::cin >> msg;
        ts->Send(msg);
    }
    ts->Close();
    delete ts;
}

int main()
{
    TcpSvr ts;
    if(!ts.CreateSock())
    {
        return 0;
    }

    if(!ts.Bind())
    {
        return 0;
    }

    if(!ts.Listen())
    {
        return 0;
    }

    while(1)
    {
        TcpSvr* ts2 = new TcpSvr();
        struct sockaddr_in cliaddr;
        if(!ts.Accept(ts2, &cliaddr))
        {
            continue;
        }
        std::cout << "Server have a new conncet, " << inet_ntoa(cliaddr.sin_addr) << ":" << ntohs(cliaddr.sin_port) << std::endl;
        
        pthread_t tid;
        int ret = pthread_create(&tid, NULL, ThreadStart, (void*)ts2);
        if(ret < 0)
        {
            std::cout << "Create thread failed" << std::endl;
            return 0;
        }
    }
    
    ts.Close();
    return 0;
}

#include "tcpsvr.hpp"

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        std::cout << "./cli [ip]" << std::endl;
        return 0;
    }
    std::string ip = argv[1];

    TcpSvr ts;
    if(!ts.CreateSock())
    {
        return 0;
    }

    struct sockaddr_in svraddr;
    svraddr.sin_family = AF_INET;
    svraddr.sin_port = htons(PORT);
    svraddr.sin_addr.s_addr = inet_addr(ip.c_str());
    if(!ts.Connect(&svraddr))
    {
        return 0;
    }

    while(1)
    {
        std::string msg;
        std::cout << "client say:";
        fflush(stdout);
        std::cin >> msg;
        ts.Send(msg);

        ts.Recv(msg);
        std::cout << "server say:" << msg << std::endl;
    }

    ts.Close();
    return 0;
}
一杆梅子酒丶
关注
专栏目录
Socket网络编程（TCP和UDP）
09-05
Socket网络编程（TCP和UDP）,基于VS2013编译，简单的网络通信示例
socket通信_UDP
qq_41661056的博客
07-28 285
服务端： import socket # TCP: 9999 # UDP:9999 HOST = '172.25.254.250' PORT = 9999 server = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM) # 绑定端口: server.bind((HOST, PORT)) # 不需要调用监听方法 pr...
深入解析网络编程：Socket基础与操作详解
最新发布
无敌岩雀的博客
07-30 1039
这是因为在网络传输中，需要保证数据的一致性。因此，当数据在网络中传输时，必须按照大端序排列。为了确保数据在网络中正确传输，需要将主机字节顺序（Host Byte Order）转换为网络字节顺序。我们通常使用的有两种数据类型：短型（两个字节）和长型（四个字节）。
Socket网络编程（一）——UDP
小菜鸡的博客
04-14 235
Socket网络编程（一） 使用UDP完成通信 UDP是面向无连接的协议。就像以前发邮件，只需要将数据发送出去，不需要知道对方是否收到。在使用UDP协议时，只需要知道对方的ip及端口号，则可以发送数据。 服务器： import socket def udp_server(): #创建套接字 udp_socket = socket.socket(socket.AF_INET, so...
UDP之socket通信
xiaoyuxianshenging的博客
04-03 447
UDP和TCP的对比。 　　–UDP处理的细节比TCP少。 　　–UDP不能保证消息被传送到目的地。 　　–UDP不能保证数据包的传递顺序。 　　–TCP处理UDP不处理的细节。 　　–TCP是面向连接的协议。 　　–UDP是无连接协议。 　　–TCP保持一个连接。 　　–UDP只是把数据发送出去而已。 UDP和TCP在socket通信所用的代码基本类似 不同之处：
socket网络编程udp
Believe in the Future的专栏
07-24 298
#!/usr/bin/env python #-*-coding:utf-8-*- #udp socketserver客户端 import socket HOST='127.0.0.1' PORT=3214 s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) data='你好！' s.sendto(data.encode('utf-8'),(HO
基于cpp的socket实现C:S的TCP:UDP通信样例.zip
03-30
在IT领域，网络通信是计算机...通过研究此项目，开发者不仅能掌握基本的socket编程技巧，还能进一步提升在网络编程领域的实战能力。交流与学习是IT行业发展的重要驱动力，欢迎所有对此感兴趣的人参与讨论，共同进步。
C#winform TCP通信 UDP通信 Socket通信 vs2017 .net4.0
10-30
总结来说，"C# WinForm TCP通信 UDP通信 Socket通信 vs2017 .net4.0"项目是一个学习和实践C#网络编程的好材料。通过此项目，开发者可以深入理解TCP和UDP的区别，掌握如何在C#环境中使用Socket进行网络通信，并了解...
ethnet udp tcp.rar_TCP UDP SOCKET_TCP/UDP通信_tcp套接字_udp 程序
09-24
在TCP通信中，客户端首先发起连接请求，服务器响应并建立连接，然后双方就可以进行双向通信。TCP通过确认机制、重传策略以及滑动窗口等机制来实现可靠性。 相比之下，UDP是一种无连接的、不可靠的协议。它不保证...
欧姆龙TCP UDP Socket网络通讯.zip
11-12
本资源"欧姆龙TCP UDP Socket网络通讯.zip"提供了关于如何利用TCP和UDP协议通过Socket进行欧姆龙PLC设备通信的实例。以下是关于这个主题的详细知识点： 1. **Socket基础**： - Socket是一种网络编程接口，用于在...
网络编程：UDP的socket编程(Linux)
Zyc_cucumber的博客
08-26 2813
文章目录前言一、UDP协议1.简单了解UDP协议2.网络字节序二、UDPsocket编程1.编程流程2.编程接口①创建套接字(socket)②绑定地址信息(bind)③发送数据(sendto)④接收数据(recvfrom)3.服务端测试3.客户端代码4.服务端代码5.连接测试6.缓冲区的概念 前言 本篇文章介绍UDP的socket编程流程，使用的接口都是Linux操作系统中的接口。这些编程接口可能与Windows操作系统中有些不同。文章中如果发现有错误的地方，可以一起讨论！！！ 一、UDP协议 1.简单
udp socket通信
hahachenchen789的博客
11-08 464
server端： #include #include #include #include #include #include #include #include #include #define PORT 7089 #define BUFFER_SIZ
【c#编程技术总结】Socket通信 Udp
纯技术流日常开发商业开发记录总结等
03-13 366
欢迎加入Unity业内qq交流群：956187480 qq扫描二维码加群 Udp是没有绝对的c/s观念的，只是为了方便设定了客户端，服务端。此篇是搭载Unity使用的。.Net下也可以 public class UdpManager : MonoBehaviour { public Button server; public Button client; ...
socket udp通信
yuan08shandong的博客
12-28 403
基本流程： 1）udp套接字创建 调用socket()函数，采用SOCK_DGRAM方式，创建一个基于UDP的套接字。 2）地址与端口的绑定 绑定一个ip地址与端口，仍是bind函数 3）数据收发 调用sendto和recvfrom（）函数进行数据收发。在UDP不需要调用connect()、listen()、accept()函数，因为UDP在通信时不需要保持连接。 4）套接字关闭
Socket UDP通讯
zhuxb523的专栏
04-08 465
UDP简单的分析以及TCP和Socket之间的区别 UDP：面向非连接、传输不可靠、用于传输少量数据(数据包模式)、速度快。 UDP不是面向连接的，UDP传送数据不需要和服务器连接，只需要知道ip和监听端口，不需要链接没有目的的socket，只是将数据报投递出去，不管接收方是否成功接收到，因此是一种不可靠的传输。 但是UDP的开销更小数据传输速率更高，因为不必进行收发数据的确认，所以UD
Socket之UDP通信
moluchase的专栏
08-06 553
简单记之，留后用 先实现一对一通信 服务器类 public class UDPServer { public static void main(String[] args) throws IOException { /* * 服务器接收数据 */ //创建DatagramSockte对象，并指定端口号 DatagramSocket socket=new Da
socket之UDP通信
Peter_tang6的博客
06-28 581
人生是一座富矿，有待于自身去开采。 —— 崔鹤同 前面写了关于socket的TCP通信，今天介绍的是另一种无连接的通信方式，UDP通信。UDP 是User Datagram Protocol的简称， 中文名是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联） 参考模型中一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务，IETF RFC 76
Socket通信讲解及C/S结构实现UDP协议通信
weixin_45266856的博客
05-29 3380
所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制，是支持TCP/IP协议的路通信的基本操作单元。
网络基础篇——socket网络编程之UDP通信
zw_1510的博客
07-27 509
UDP和TCP的区别：UDP是无连接的、不可靠的数据协议报，而TCP是面向连接的，提供可靠的字节流。然而，有些情况更适合用UDP而不是TCP。有些流行的应用程序就是用UDP实现的：DNS(域名系统）、NFS（网络文件系统）和SNMP（简单网络管理协议）还有就是qq也是使用的UDP。 UDP和TCP通信模型类似，只是不需要连接，具体过程如下。 1、创建socket 创建一个UDP协议的套接字so
Java网络编程：UDP与TCP/IP详解
此外，Java的Socket和ServerSocket类分别用于实现TCP和UDP通信，提供了创建连接、发送和接收数据的接口。 Java中的网络编程涵盖了广泛的概念和技术，从基础的网络架构到复杂的协议交互，都需要开发者具备扎实的理论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值