【Linux 网络编程1】使用UDP/TCP编写套接字，多进程/多线程版本的TCP编写的套接字，将套接字封装

最新推荐文章于 2023-08-08 08:57:03 发布
最新推荐文章于 2023-08-08 08:57:03 发布
阅读量641 收藏 4
点赞数 5
分类专栏： Linux 文章标签： 网络 服务器 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72964546/article/details/129228737
版权

目录

1.学习网络编程前的一些基础知识

2.UDP(user datagram protocol)协议的特点

3.使用有UPD编写套接字

4.使用TCP编写套接字

4.2.TCP客服端 

4.3.TCP服务器端

4.4.单进程版本（没有人会使用）

4.5.多进程版本

4.6.多线程版本

5.把套接字封装

1.学习网络编程前的一些基础知识

1.1.IP地址

  • IP地址是在IP协议中, 用来标识网络中不同主机的地址（一个IP地址标识一台主机）；
  • 通常使用 "点分十进制" 的字符串表示IP地址, 例如127.0.0.1 ; 用点分割的每一个数字表示一个字节, 范围是 0 - 255，就是一个字节的大小，IP地址刚好是4字节, 32位的整数；

1.2.端口号（port） 

  • 端口号是一个2字节16位的整数
  • 端口号用来标识一个进程，那么IP地址+端口号就可以标识某一台主机的某一个进程

1.3.TCP/IP四层模型 

 

1.4.网络字节序 

  • 网络字节序就是大端字节序（低位放在高地址上），使用相同的字节序便于网络间通信；

有系统提供的接口 

2.UDP(user datagram protocol)协议的特点

UDP协议是一个传输层协议

  • 无连接:没有连接，客户端发给服务器端，服务器端要先保存客户端的信息，服务器端再使用这个信息发给对应的客户端（简单地说就是需要指明发送给谁）
  • 不可靠传输：只是传递数据，成功与否都不会反馈
  • 面向数据报：不能向面向字节流的TCP一样使用read和write来读写

3.使用有UPD编写套接字

3.1.服务器端

3.1.1.创建套接字

    int sock=socket(AF_INET,SOCK_DGRAM,0);//创建套接字
    if(sock<0)
    {
        std::cerr<<"socket fail: "<<errno<<std::endl;
        return 1;
    }

3.1.2.bind服务器 

网络字节序就是大端字节序（低位放在高地址上），使用相同的字节序便于网络间通信；

  1. 1.需要将人识别的点分十进制，字符串风格IP地址，转化为4字节整数IP.2.考虑大小端的问题

服务器不用bind一个固定的IP的原因

  1. 1.云服务器，不允许bind公网IP，另外，在一般编写也不会指明IP.2.一般主机有多个IP，如果只是bind一个IP，发给其他IP的数据就不会交给主机处理
  2. INADDR_ANY只要是发给这个主机的数据都会被处理

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(port);
    //1.需要将人识别的点分十进制，字符串风格IP地址，转化为4字节整数IP.2.考虑大小端的问题
    //1.云服务器，不允许bind公网IP，另外，在一般编写也不会指明IP.2.一般主机有多个IP，如果只是bind一个IP，发给其他IP的数据就不会交给主机处理;
    //INADDR_ANY只要是发给这个主机的数据都会被处理
    local.sin_addr.s_addr=INADDR_ANY;
    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)//bind主机
    {
        std::cerr << "bind error : " << errno << std::endl;
        return 2;
    }

3.1.3.传递接受数据

  • UDP是无连接的，需指明发给谁，也需要保存发送端的信息

    //业务逻辑
    char message[1024];
    bool quit=false;
    while(!quit){
        //保存发送端信息
        struct sockaddr_in peer; 
        socklen_t len=sizeof(peer);
        //接受数据
        ssize_t s=recvfrom(sock,message,sizeof(message)-1,0,(struct sockaddr*)&peer,&len);
        if(s>0){
            message[s]=0;
            std::cout<<"client# "<<message<<std::endl;
        }else{
            std::cerr<<"recvfrom"<<errno<<std::endl;
            return 2;
        }
        //给对端发送一个你好吗
        std::string tm="你好吗?";
        std::cout<<"server to client: "<<tm<<std::endl;
        sendto(sock,tm.c_str(),tm.size(),0,(struct sockaddr*)&peer,len);
    }

 3.2.客户端

  • 客户端不需要显示bind，当传输第一个数据是会自动随机bind一个port(没有被使用的port)
#include<iostream>
#include<cerrno>
#include<string>
#include<cstdlib>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

//client serverIP serverPort
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        std::cout<<"请按格式输入: client serverIP serverPort"<<std::endl;
        return 2;
    }
    int sock=socket(AF_INET,SOCK_DGRAM,0);//创建套接字
    if(sock<0)
    {
        std::cout<<"socket create errno: "<<errno<<std::endl;
        return 1;
    }
    //客户端不用显示bind，OS会自动bind；
    //服务器端会有规划，让port是没有被占用的，让别人来访问这个port；
    //client正常发送数据的时候，OS会自动给你bind，采用随机端口的方式

        struct sockaddr_in server;
        server.sin_family=AF_INET;
        server.sin_port=htons(atoi(argv[2]));
        server.sin_addr.s_addr=inet_addr(argv[1]);
    while(1)
    {
        std::string message;
        std::cout<<"请输入#";
        std::cin>>message;

        sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));

        struct sockaddr_in tmp;
        socklen_t tlen=sizeof(tmp);
        char buffer[1024];
        ssize_t s=recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&tmp,&tlen);
        if(s>0){
            std::cout<<"server say#: "<<buffer<<std::endl;
            buffer[s]=0;   
        }else{
            std::cerr<<"recvfrom"<<errno<<std::endl;
            return 2;
        }
    }
    return 0;
}

4.使用TCP编写套接字

4.1.TCP的特点

TCP是一个传输层协议，和UDP的特点相反

  • 有连接
  • 可靠传输
  • 面向字节流

4.2.TCP客服端 

先写的客户端，因为服务器端会写多个版本

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

void Usage()
{
    std::cout<<"usage:./client server_IP server_port"<<std::endl;
}
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        Usage();
        return 1;
    }
    //建立套接字
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0){
        std::cerr<<"socket"<<errno<<std::endl;
        return 2;
    }
    //自动bind
    //连接服务器
    struct sockaddr_in local;
    local.sin_addr.s_addr=inet_addr(argv[1]);
    local.sin_port=htons(atoi(argv[2]));
    local.sin_family=AF_INET;
    connect(sock,(struct sockaddr*)&local,sizeof(local));


    //业务逻辑
    while(1)
    {
        char buffer[1024]={0};
        std::cout<<"请输入";
        fgets(buffer,sizeof(buffer),stdin);
        write(sock,buffer,sizeof(buffer));

        char mes[1024]={0};
        read(sock,mes,sizeof(mes));
        std::cout<<mes<<std::endl;
    }
    return 0;
}

4.3.TCP服务器端

4.3.1.创建套接字和bind服务器

  • socket的第二个参数是SOCK_STREAM,UPD是SOCK_DGRAM（datagram）,TCP是SOCK_STREAM（stream，就是字节流）
//建立套接字
    int listen_sock=socket(AF_INET,SOCK_STREAM,0);
    if(listen_sock<0)
    {
        std::cerr<<"socket"<<errno<<std::endl;
        return 1;
    }
    //bind服务器
    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(PORT);
    local.sin_addr.s_addr=INADDR_ANY;//INADDR_ANY会bind执行代码的主机

    if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        std::cerr<<"bind"<<errno<<std::endl;
        return 2;
    }

4.3.2.listen设为聆听状态

    //listen状态
    listen(listen_sock,5);

 4.3.3.accept接受客户端的连接，并返回一个文件描述符

  • 因为TCP套接字是有连接的，连接成功后也是使用返回的套接字和对端进行网络通信

struct sockaddr_in tmp;
socklen_t tlen=sizeof(tmp);
//建立连接
int fd=accept(listen_sock,(struct sockaddr*)&tmp,&tlen);

4.4.单进程版本（没有人会使用）

  • 一次只能让一个客户端访问
  • 写端关闭读端读到文件结尾，再读返回0
int main()
{
    //...创建套接字、bind、listen都省略了，每次都一样冗余
    while(1)
    {
        struct sockaddr_in tmp;
        socklen_t tlen=sizeof(tmp);
        //建立连接
        int fd=accept(listen_sock,(struct sockaddr*)&tmp,&tlen);
        if(fd<0)
        {
            std::cerr<<"accept "<<errno<<std::endl;
            return 3;
        }
        std::cout<<"get a new link "<<std::endl;
        
        //1.单进程version
        while(1)
        {
            char buffer[1024]={0};
            ssize_t s=read(fd,buffer,sizeof(buffer));
            if(s>0){
                buffer[s]=0;
                std::cout<<"client to server:"<<buffer<<std::endl;
                
                std::string message;
                message+="server to client:你好!";
                //给连接的客户端发一个你好
                write(fd,message.c_str(),message.length());
            }
            else if(s==0){//写端关闭读端读到文件结尾，再读返回0
                std::cout<<"client quit!"<<std::endl;
                break;
            }
            else{
                std::cerr<<"read "<<errno<<std::endl;
                break;
            }
        }
    }
}

4.5.多进程版本

4.5.1.父进程是一个循环，他要一直接收新的客服端不能等待子进程,解决方法

  1. 父进程等待子进程，子进程创建后再创建孙子进程执行后序代码，子进程秒退等待时间可以忽略不计；下面代码

pid_t pid = fork();
        if(pid<0){
            continue;
        }
        else if(pid==0){//子进程
            close(listen_sock);
            if(fork()>0)
                exit(0);//子进程创建就直接退出，创建的孙子进程执行后序代码，孙子进程变成孤儿进程被1号进程领养
            serviceIO(fd);
            close(fd);
            exit(0);
        }
        else{//父进程
            close(fd);//子进程的PCB以父进程的PCB做模板初始化，不是共享的
            //waitpid(&pid,NULL,0);//父进程等待子进程，子进程创建后再创建孙子进程执行后序代码，子进程秒退等待时间可以忽略不计
        }

        2.signal(SIGCHLD,SIG_IGN);//忽略SIGCHLD信号，子进程将自动释放； 

2.关闭不用的文件描述符，父进程关闭accept返回的文件描述符，子进程关闭socket返回的文件描述符

void serviceIO(const int& fd)
{
    //1.单进程version,做成一个函数
    while(1)
    {
        char buffer[1024]={0};
        ssize_t s=read(fd,buffer,sizeof(buffer));
        if(s>0){
            buffer[s]=0;
            std::cout<<"client to server:"<<buffer<<std::endl;
            std::string message;
            message+="server to client:你好!";
            //给连接的客户端发一个你好
            write(fd,message.c_str(),message.length());
        }
        else if(s==0){//写端关闭读端读到文件结尾，再读返回0
            std::cout<<"client quit!"<<std::endl;
            break;
        }
        else{
            std::cerr<<"read "<<errno<<std::endl;
            break;
        }
    }
}
       
int main()
{
    //...创建套接字、bind、listen都省略了，每次都一样冗余
    signal(SIGCHLD,SIG_IGN);//忽略SIGCHLD信号，子进程将自动释放
    while(1)
    {
        struct sockaddr_in tmp;
        socklen_t tlen=sizeof(tmp);
        //建立连接
        int fd=accept(listen_sock,(struct sockaddr*)&tmp,&tlen);
        std::cout<<"get a new link "<<std::endl;
        if(fd<0)
        {
            std::cerr<<"accept "<<errno<<std::endl;
            return 3;
        }
        //2.多进程version
        pid_t pid = fork();
        if(pid<0){
            continue;
        }
        else if(pid==0){//子进程
            close(listen_sock);
            serviceIO(fd);
            close(fd);
            exit(0);
        }
        else{//父进程
            close(fd);//子进程的PCB以父进程的PCB做模板初始化，不是共享的
        }
         
    }
}

4.6.多线程版本

  • 线程是共享PCB的，所以在线程内使用完毕关闭文件描述符即可；
  • 不等待线程可以使用线程分离的方法
void serviceIO(const int& fd)
{
    //1.单进程version
    while(1)
    {
        char buffer[1024]={0};
        ssize_t s=read(fd,buffer,sizeof(buffer));
        if(s>0){
            buffer[s]=0;
            std::cout<<"client to server:"<<buffer<<std::endl;
            std::string message;
            message+="server to client:你好!";
            //给连接的客户端发一个你好
            write(fd,message.c_str(),message.length());
        }
        else if(s==0){//写端关闭读端读到文件结尾，再读返回0
            std::cout<<"client quit!"<<std::endl;
            break;
        }
        else{
            std::cerr<<"read "<<errno<<std::endl;
            break;
        }
    }
}
void* HandlerRequest(void* agrs)
{
    pthread_detach(pthread_self());
    int fd=*((int*)agrs);
    serviceIO(fd);
    close(fd);//记得关闭文件描述符
}
int main()
{
   
    while(1)
    {
        struct sockaddr_in tmp;
        socklen_t tlen=sizeof(tmp);
        //建立连接
        int fd=accept(listen_sock,(struct sockaddr*)&tmp,&tlen);
        std::cout<<"get a new link "<<std::endl;
        if(fd<0)
        {
            std::cerr<<"accept "<<errno<<std::endl;
            return 3;
        }

        pthread_t tid;
        pthread_create(&tid,nullptr,HandlerRequest,(void*)&fd);
    }
    return 0;
}

5.把套接字封装

  • 使用静态是因为不用创建对象就可以使用sock::Socket()等函数;
#pragma once
#include<iostream>
#include<cstdlib>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>

namespace ns_socket{
    class sock{
    public:
        static int Socket()
        {
            int sock=socket(AF_INET,SOCK_STREAM,0);
            if(sock<0)
            {
                std::cerr<<"socket"<<std::endl;
                exit(1);
            }
            return sock;
        }
        static void Bind(int sock,char* port)
        {
            struct sockaddr_in local;
            local.sin_family=AF_INET;
            local.sin_addr.s_addr=INADDR_ANY;
            local.sin_port=htons(atoi(port));
            if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
            {
                std::cerr<<"bind"<<std::endl;
                exit(2);
            }
        }
        static void Listen(int sock)
        {
            if(listen(sock,5)<0)
            {
                std::cerr<<"listen"<<std::endl;
                exit(3);
            }
        }
        static int Accept(int sock) 
        {
            struct sockaddr_in tmp;
            socklen_t tlen=sizeof(tmp);
            int new_sock=accept(sock,(struct sockaddr*)&tmp,&tlen);
            if(new_sock<0)
            {
                std::cerr<<"accept"<<std::endl;
                exit(4);
            }
            return new_sock;  
        }
        static void Connect(int sock,char* server_ip,char* server_port)
        {
            struct sockaddr_in local;
            local.sin_family=AF_INET;
            local.sin_addr.s_addr=inet_addr(server_ip);
            local.sin_port=htons(atoi(server_port));
            if(connect(sock,(struct sockaddr*)&local,sizeof(local))<0)
            {
                std::cerr<<"connect"<<std::endl;
                exit(5);
            }
            else
            {
                std::cout<<"connet success"<<std::endl;
            }
        }
    };
}

一个普通的小白
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
TCP和UDP套接字_简单的客户/服务器
06-10
在IT领域，网络通信是核心部分之一，而TCP（传输控制协议）和UDP（用户数据报协议）则是两...在设计客户/服务器系统时，根据业务需求灵活选择TCP或UDP，结合多线程编程，可以构建出能够满足大规模并发访问的网络服务。
基于UDP和TCP协议的Socket(网络编程/套接字)案例
10-30
Socket，也被称为套接字，是网络编程中的一个重要概念，它是不同计算机进程间通信的一种机制。在Java中，Socket提供了一种标准的方式来实现基于TCP（传输控制协议）和UDP（用户数据报协议）的网络通信。这两种协议在...
Linux--Upd--套接字编程（单线程和多线程版本）--0215 16
qq_68741368的博客
02-18 619
udp套接字编程 单线程以及基于其的多线程改良版本
linux网络编程05--线程池UDP
最新发布
cat_fish_rain的博客
08-08 181
什么时候需要创建线程池呢？简单的说，如果一个应用需要频繁的创建和销毁线程，而任务执行的时间又非常短，这样线程创建和销毁的带来的开销就不容忽视，这时也是线程池该出场的机会了。需要注意的是: bind函数会自动创建socket文件, 若在调用bind函数之前socket文件已经存在, 则调用bind会报错, 可以使用unlink函数在bind之前先删除文件.使用回到函数, 在任务中设置任务执行函数, 这样可以起到不同的任务执行不同的函数.TCP：传输控制协议, 面向连接的，稳定的，可靠的，安全的数据流传递。
Socket套接字在多线程发送数据时要加锁吗？
zxh2075的专栏
03-02 2971
转自知乎 问题：一条报文在1000字节到4000字节之间，数据量在每秒5000左右，多线程写套接字，要加锁吗？没有加锁会导致报文错乱吗？在网络编程的时候，报文不超过MTU是否就无需对套接字加锁？ 解答①： 你连 UDP 还是 TCP 都没说。 对于 UDP，多线程读写同一个 socket 不用加锁，不过更好的做法是每个线程有自己的 socket，避免 contention，可以用 SO_R...
【Linux网络（C++)】——网络套接字（TCP/UDP编程模型）多进程，多线程，线程池服务器开发（画图解析）
sjp11的博客
02-22 5146
TCP/IP协议传输层的主要任务是向位于不同的（有时候位于同一主机）上的应用程序提供端到端的通信服务，为了区分应用程序，TCP和UDP引入了端口号的概念。 端口号 端口号（port）是传输层协议的内容 是一个2字节的16位整数。 端口号是用来表示进程的，告诉操作系统，当前的数据要交给哪一个进程处理 ip地址+端口号能够标识网络上一台主机上的一个进程。 一个端口号只能标识一个进程 在同一台机器上，进程的间的端口号都是不同的。 任何的网络服务与网络客户端，如果要进行正常的数据通信，必须使用..
TCP实现多线程下文件的上传
喵了个@汪的博客
08-14 302
多线程下文件的上传: 要想实现此需求，我们首先要掌握多线程的相关知识【线程的的实现方法】、以及用IO流进行数据的传输和用TCP协议发送和接收数据。 模拟多线程下文件的上传的客户端 技术分析：客户端我们使用Socket类【套接字】提供的方法 【重点实现思路】 run方法： 1、创建套接字对象【Socket】---参数服务端的ip和port； 2、创建输入流对象--读取磁盘文件的数据到内存； 3、获取输出流对象--将内...
Socket通讯实例1.rar_tcp/ip通讯_套接字
09-14
总的来说，这个实例将帮助你理解TCP/IP通信的流程，熟悉套接字编程的基本操作，为后续的网络编程打下坚实基础。在实践中，你还需要注意异常处理、多线程以及性能优化等方面的问题，这些都是Socket编程中不可或缺的...
tcp+udp.rar_TCP/IP_linux udp socket_linux 网络编程_socket linux udp
09-20
至于"socket linux udp"，则意味着这个资源可能特别关注Linux环境下的UDP套接字编程，可能涉及多线程、多进程处理、异步I/O或者网络并发等高级主题。 根据压缩包内的文件名"udp2"和"tcp"，我们可以推测，"udp2"可能...
实验三socket编程代码.rar_socket编程_tcp/udp_一对多聊天_多人聊天室_计算机网络实验
09-25
在TCP Socket编程中，服务器会创建一个监听套接字，等待客户端的连接请求。一旦客户端连接成功，就会形成一个连接套接字，双方可以通过这个连接进行双向通信。实验中的“一对一处理客户机的信息”即指此过程，服务器...
linux多线程+UDP网络通信（总结+程序）
11-11
linux系统下建立多线程程序设计，完成UDP网络通信的发送与接收，包括总结与源代码,实测效果可见链接https://blog.csdn.net/zxp121127/article/details/78506081
java 套接字线程_多个线程从同一个套接字读取
weixin_32911063的博客
02-25 207
一个非常简单明了的方法如下：您创建一个新的 Service ，它在后台运行并通过套接字与服务器通信Service 从套接字接收数据并将其转发/广播到您有兴趣接收它的所有活动(例如更新UI)，使用 LocalBroadcastManager您的所有活动都实现 BroadcastReceiver 并从 onReceive() 方法中接收 Service 中的数据要实现这一点，您应该阅读Services...
node多进程的创建与守护
终极冥帝
01-02 225
node是单线程运行，我们的node项目如何利用多核CPU的资源，同时提高node服务的稳定性呢？ 1. node的单线程时光小说 https://wap.youxs.org/ 进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。 线程是程序执行中一个单一的顺序控制流，它存在于进程之中，是比进程更小的能独立...
Linux C/C++ 多线程TCP/UDP服务器 (监控系统状态)
chen1415886044的博客
02-19 2267
Linux环境中实现并发TCP/IP服务器。多线程在解决方案中提供了并发性。由于并发性，它允许多个客户端同时连接到服务器并与服务器交互。
TCP/UDP底层实现(c实现)の四
jack的博客
01-08 2436
linux下多线程服务和windows多线程
socket多线程 , 多进程编程及UDP编程(实现一个服务器 n个客户端)
Nonpc的博客
04-08 5382
多线程服务器端的实现 在之前的文章已经详细介绍过socket网络编程 , 那么接下来让我们看看多线程的网络编程如何实现 大体的思路就是在accpet之后 , 创建一个新的线程供客户端所使用. 以下是服务器端代码 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<string.h...
linux C/C++ socket编程
qq_37026934的博客
09-04 3907
socket
[Linux] 网络编程 - 初见TCP套接字编程: 实现简单的单进程、多进程、多线程、线程池tcp服务器
七月.cc的博客
07-15 556
UDP和TCP的部分特点. 最主要的区别就是: 1. UDP非连接, 面向数据包 2. TCP连接, 面向字节流 所以, TCP多了三个用于连接的接口: connect()、listen()和accept() 这三个接口具体怎么使用, 下面实现简单的TCP网络通信时 介绍一下.
Linux网络：Socket套接字编程 | TCP
FamerSaul的博客
08-20 377
流套接字TCP协议编程的流程，三次握手和四次挥手的简单认识。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值