linux学习之Socket

目录

编写socket-udp

第一步，编写套接字

第二步，绑定端口号

第三步，启动服务器，读取数据

第四步，接收消息并发回信息给对方

编写socket-Tcp

第一步，编写套接字

第二步，绑定端口号

第三步，将套接字设置为监听状态。

第四步，在服务器运行里获取新连接

第五步，进行读写通信

编写socket-udp

如何认识快速的Udp，我们先来编写一个udp服务器。

第一步，编写套接字

int socket
创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器 )
第一个参数domain即创建套接字的域，如下表：
看以看到有ipv4,ipv6,ipx等。

 第二个参数为类型  当前socket的类型，如下图所示：

例如sock_stream为有序的可靠的字节流 ，sock_DGRAM为数据报类型等

 第三个为参数protecal,指定域套接字一起使用的特定协议，通常在给定协议族中，只存在一个协议来支持特定的套接字类型。

创建成功会返回一个新的套接字，失败则会返回-1.

第二步，绑定端口号

接口bind

第一个参数为sockfd，套接字id，第二个为套接字类型，这里我们是网络接口，所以应该使用struct sockaddr_in类型的接口。但是我们一般也不会去创建，而是直接定义初始化内存直接用。这里用bzero来初始化内存为0：

之后初始化结构体的内容，设置结构体类型，端口号，ip地址。

之后进行由主机序列转到网络序列：

htons接口：

这些函数名很好记 ,h 表示 host,n 表示 network,l 表示 32 位长整数 ,s 表示 16 位短整数
例如 htonl 表示将 32 位的长整数从主机字节序转换为网络字节序 , 例如将 IP 地址转换后准备发送。
如果主机是小端字节序 , 这些函数将参数做相应的大小端转换然后返回 ;
如果主机是大端字节序 , 这些 函数不做转换 , 将参数原封不动地返回。

 除了端口号，一般在发送数据时，还需要连ip地址一起打包成封装发送出去，因此对于ip地址我们人需要转化成网络字节序列。分两步转化，现将字符串转化为四字节（uint32_t），再转化为网络字节序列。

当然系统也为我们提供了字符串转为网络字节序的接口 inet_addr:

之后开始绑定，注意结构体（套接字）类型一致，绑定成功返回0，失败返回-1.

第三步，启动服务器，读取数据

recvfrom接口  从套接字中获取消息：

 参数一位网络文件描述符，参数二为获取的消息，参数三为长度，参数四为标志，当前我们就设置为0，参数五为接收方的套接字，参数六位套接字的大小，后面两个参数是输入型参数。成功返回获取信息的大小。

看可以看到收到消息，我们需要知道消息内容，发消息的源址。

第四步，接收消息并发回信息给对方

收到信息后，发回给对方，调用接口sendto：

 参数一为网络文件描述符，参数二为字符缓冲区，参数三为长度，参数四为标志，参数五与参数六接口域recvfrom基本一致，不过这里最后两个参数为输入型参数。

之后我们可以用 netstat -nlup 来查看创建的服务器。

需要注意一点，云服务器不能直接绑定公网ip。我们一般推荐任务地址绑定。

对于端口的选择，我们【0，1023】都是系统端口，直接绑定需要root权限，一般需要有固定的应用协议层使用。绑定我们一般选大一点的端口号。

现在我们就编写一个客户端域服务端的demo版本，先来理解UDP通信：

Udpserver.hpp

#pragma once

#include<cstring>
#include<iostream>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
//包含下面两个头文件，此时struct sockeaddr_in 初始化有提示
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;

const int Size=1024;
string defaultip="0.0.0.0";
uint16_t defaultport=8080;
enum{
    SOCKET_ERR=1,
    Bind_ERR
};


class UdpServer
{
    public:
        UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
        {

        }
        //搭建udp网络服务器
        void Init()
        {
            //1.创建套接字  协议为ipv4，类型为数据报 
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INIT
            if(_sockfd<0)
            {
                cout<<"创建套接字失败,socket:"<<socket<<endl;
                exit(SOCKET_ERR);
            }else{
                cout<<"创建套接字成功,socket:"<<socket<<endl;
            }
            //2.告诉服务器端口号，绑定端口号
            struct sockaddr_in local;
            //内容置空
            bzero(&local,sizeof(local));
            //初始化其中内容   
            local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
            local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 
            //由主机序列转到网络序列提供有接口，我们直接调用转化

            local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，
            //其次对于ip地址，我们需要将字符串转化为uint32_t 

            //初始化对象完成，开始绑定套接字,设置到内核
            if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
            {
                
                printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
                exit(Bind_ERR);
            }

            cout<<"绑定成功！！！"<<endl;


        }

        void Run()
        {
            //服务器搭建成功
            char buffer[Size];
            is_running=true;   //改变状态
            while (is_running)
            {
                //读取数据
                struct sockaddr_in client;
                socklen_t len=sizeof(client);
                ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
                if(n<0)
                {
                    printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
                    continue;
                }
                  
                buffer[n]=0; 
                cout<<"接受消息:"<<buffer<<endl;
                string info=buffer;
                string string_echo="server echo#"+info;
             
                //发回信息给对方
                sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
            }

        }

       ~UdpServer()
       {
        if(_sockfd>0) close(_sockfd);
       }



    private:
    int _sockfd;   //网络文件描述符
    uint16_t _port;//端口号
    string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。
    bool is_running;//判断服务器是否再运行
};

对应的.cc

#include"UdpServer.hpp"
#include<memory>

void Usage(string p)
{
    cout<<"\n\rUsage: "<<p<<" prot[1024] bigger "<<endl;
}

int main(int argc,char *argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(0);
    }

    
    //构建udp服务器
    uint16_t port= stoi(argv[1]);
    const string ip="0.0.0.0";
    std::unique_ptr <UdpServer> svr(new UdpServer(port,ip));
    svr->Init();
    svr->Run();

    return 0;
}

Udpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
using namespace std;
void Usage(string p)
{
    cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;

}

int main(int argc,char *argv[])
{

   
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(0);
    }
    uint16_t port=stoi(argv[2]);
    const string ip=argv[1];
    //构建服务端的套接字
     struct sockaddr_in server;
     bzero(&server,sizeof(server));
    server.sin_addr.s_addr=inet_addr(ip.c_str());
    server.sin_family=AF_INET;
    server.sin_port=htons(port);
    socklen_t len=sizeof(server);
     int sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        cout<<"create socket error"<<endl;
        return 1;
    }
    //需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
    //一个端口号只能被一个进程绑定，对于客服端也是如此
    //客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定
    string message;
    char buffer[1024];
    while(true)
    {
        cout<<"请输入你要发的消息@";
        getline(cin,message);
        //发数据报
        sendto(sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&server,len);
        cout<<".............."<<endl;
        //该客户端可能还会读取其他服务器发消息
        struct sockaddr_in temp;
        socklen_t len=sizeof(temp);
        ssize_t n=recvfrom(sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
        if(n>0)
        {
             buffer[n]=0;
            cout<<"收到消息："<<buffer<<endl;;
        }
        // if(n<0)
        // {
        //     printf("收到消息失败,errno %s,错误信息%s\n",errno,strerror(errno));
        // }else
        // {
        //     buffer[n]=0;
        //     printf("收到消息，消息：%s\n",buffer);
        // }
       

    }
    
    close(sockfd);
    return 0;
}

既然有了服务端那么我们就可以在收到信息时，让他拿到ip地址，端口号和数据报文，同时创建同时在线的用户名单，一个发，所有可以看到。其次客户端显示信息也不太好，我们可以用多线程一个用来收，一个用来发。

改良版：

Udpserver.hpp

class UdpServer
{
    public:
        UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
        {

        }

        //搭建udp网络服务器
        //udp的套接字是全双工的
        void Init()
        {
            //1.创建套接字  协议为ipv4，类型为数据报 
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INIT
            if(_sockfd<0)
            {
                cout<<"创建套接字失败,socket:"<<socket<<endl;
                exit(SOCKET_ERR);
            }else{
                cout<<"创建套接字成功,socket:"<<socket<<endl;
            }
            //2.告诉服务器端口号，绑定端口号
            struct sockaddr_in local;
            //内容置空
            bzero(&local,sizeof(local));
            //初始化其中内容   
            local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
            local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 
            //由主机序列转到网络序列提供有接口，我们直接调用转化

            local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，
            //其次对于ip地址，我们需要将字符串转化为uint32_t 

            //初始化对象完成，开始绑定套接字,设置到内核
            if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
            {
                
                printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
                exit(Bind_ERR);
            }

            cout<<"绑定成功！！！"<<endl;


        }
        string Handler(const string info,const string clientip,const uint16_t clientport)
        {
            cout<<"["<<clientip<<": "<<to_string(clientport)<<"] @"<<info<<endl;

            string res="server get a message :";
            res+=("["+clientip+":"+to_string(clientport)+"] @");
            res+=info;
            return res;
        }

        void Broadcast(const string info,const string clientip,const uint16_t clientport)  //收到消息发送给所有用户
        {
            for( auto &it :_users)
            {
                string messages=" get a message :";
                messages+=("["+clientip+":"+to_string(clientport)+"] @");
                messages+=info;

                socklen_t len=sizeof(it.second);
                sendto(_sockfd,messages.c_str(),messages.size(),0,(const struct sockaddr*)&(it.second),len);
            }
        }
        bool Checkuser(const struct sockaddr_in user,const string clientip,const uint16_t clientport)//检查用户是否存在，不存在添加用户
        {
                auto it=_users.find(clientip);
                if(it==_users.end())
                {
                    //添加用户
                    _users.insert(make_pair(clientip,user));
                    cout<<"["<<clientip<<": "<<to_string(clientport)<<"] has added to online_users"<<endl;
                }
        }  

        void Run()
        {
            //服务器搭建成功
            char buffer[Size];
            is_running=true;   //改变状态
            while (is_running)
            {
                //读取数据
                struct sockaddr_in client;
                socklen_t len=sizeof(client);
                ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
                if(n<0)
                {
                    printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
                    continue;
                }
                
                
                //获取用户的ip地址与端口号
                 uint16_t clientport=ntohs(client.sin_port);
                 std::string clientip=inet_ntoa(client.sin_addr);
                //先检测用户是否存在过
                 Checkuser(client,clientip,clientport);
                 //广播给所有用户
                 std::string info = buffer;
                 
                 Broadcast(info,clientip,clientport);
                ;
                //发回信息给对方 
                string string_echo="echo#"+info;
                sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
            }

        }

       ~UdpServer()
       {
        if(_sockfd>0) close(_sockfd);
       }



    private:
    int _sockfd;   //网络文件描述符
    uint16_t _port;//端口号
    string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。
    bool is_running;//判断服务器是否再运行

    //保存客户端用户信息
    std::unordered_map<string,struct sockaddr_in> _users;
};

ucpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<pthread.h>
using namespace std;

struct ThreadDate
{
    int sockfd;
    struct sockaddr_in server;

};
void Usage(string p)
{
    cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;

}

void *send_message(void *args)
{
        ThreadDate *td=static_cast<ThreadDate*>(args);
        std::string message;
        socklen_t len=sizeof(td->server);
        while(true)
        {
            cout<<"请输入你要发的消息@";
            getline(cin,message);
            //发数据报
            sendto(td->sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&(td->server),len);
            cout<<".............."<<endl;
        }

 }
void *recive_mesage(void *args)
{
        ThreadDate *td=static_cast<ThreadDate*>(args);
        char buffer[1024];
        while(true)
        {
            struct sockaddr_in temp;
            socklen_t len=sizeof(temp);
            ssize_t n=recvfrom(td->sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
            if(n>0)
            {
                buffer[n]=0;
                cout<<"收到消息："<<buffer<<endl;;
            }
        }
}
int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(0);
    }

    uint16_t port=stoi(argv[2]);
    const string ip=argv[1];
    struct ThreadDate td;
    //初始化服务端的套接字
     bzero(&td.server,sizeof(td.server));
    td.server.sin_addr.s_addr=inet_addr(ip.c_str());
    td.server.sin_family=AF_INET;
    td.server.sin_port=htons(port);
    socklen_t len=sizeof(td.server);
    td.sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(td.sockfd<0)
    {
        cout<<"create socket error"<<endl;
        return 1;
    }
    //需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
    //一个端口号只能被一个进程绑定，对于客服端也是如此
    //客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定

    //创建两个线程  一个用来接受，一个用来发送
    pthread_t reciver,sender;
    pthread_create(&reciver,nullptr,recive_mesage,&td);
    pthread_create(&sender,nullptr,send_message,&td);    

    pthread_join(reciver,nullptr);
    pthread_join(sender,nullptr);

这里在编写的时候注意地址转化函数，,sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP 地址 但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示 和in_addr表示之间转换;

 其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr。

关于inet_ntoa：inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是否需要调用者手动释放呢?

实际上内部放在了静态区中，但是多线程在竞争调用时，还是会出现线程安全，现在在centos7上好像做了改善，里面加了锁，但是应用的时候，如果我们不放心还是尽量使用inet_mtop这样的接口。

编写socket-Tcp

学了Udp套接字的编写，Tcp相对来说会好一点，因为Tcp与Udp本来就是有交集的。

首先刚开始的套路一样：

第一步，编写套接字

与udp一样，创建sockfd文件描述符。不过这里的参数二即类型我们设置为 SOCK_STREAM（数据流）类型。

第二步，绑定端口号

在绑定端口号前，需要创建sock_addrin结构体并初始化，在将字符串Ip地址转化为网络字节序，我们这里使用的接口为inet_aton().

 参数一为char*类型ip，参数二为sin_addr.

第三步不一样。

第三步，将套接字设置为监听状态。

listen  将套接字设置为监听状态

成功返回0，错误返回-1.第二个参数代表列表长度。

第四步，在服务器运行里获取新连接

accept获取新连接  

参数一文件描述符，后两个参数为输出型参数，为addrin及其长度，可以获知哪一个客户端的信息。返回值成功返回文件描述符，否则返回-1。

与Udp不同，udp的套接字从始至终都只有一个，而Tcp有两个，实际上最开始的套接字，并不是我们要去通信的套接字，Tcp通信的套接字，是要在accept之后的套接字。因此之前的套接字，我们也可以叫做监听套接字。

之后我们就可以测试了，即使我们没写客户端，但在系统下会有一个工具telnet,可以指定登录远程服务器。

这里注意一点，无论是Tcp还是Udp我们都无法绑定公网ip。

第五步，进行读写通信

与Udp不同，我们这里不使用recvfrom与sendto接收发送消息，而是用文件描述符进行通信。

用read与write。

之后就可以编写客户端进行通信了。

对于客户端通过connect发起连接。

后两个参数为输出型参数，用来保存信息。成功返回0，否则-1.

Tcpserver.hpp

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
using namespace std;
// 错误码
enum
{
    SOCKERROR = 2,
    BINDERROR,
    LISTENERROR,
    ACCEPTEEROR
};
const uint16_t defaultfd = -1;
const std::string defaultip = "127.0.0.1";
const uint16_t defaultport = 8080;
class TcpServer;
struct PthreadData
{
    PthreadData( int sockfd,std::string clientip,uint16_t port,TcpServer*tcp):_newsockfd(sockfd),_clientip(clientip),_clientport(port),_server(tcp)
    {

    }
    int _newsockfd;
    std::string _clientip;
    uint16_t _clientport;
    TcpServer *_server;
};
class TcpServer
{
public:
    TcpServer(const uint16_t port = defaultport, const int socket = defaultfd, const string ip = defaultip) : _port(port), _listensockfd(socket), _ip(ip)
    {
    }

    void Init()
    {
        // 创建套接字
        _listensockfd = socket(AF_INET, SOCK_STREAM, 0); // TCP我们使用流类型
        if (_listensockfd == -1)
        {
            cout << "错误码：" << errno << ",错误信息: " << strerror(errno) << endl;
            exit(SOCKERROR);
        }

        cout << "创建成功......" << endl;
        // 创建sockaddr 并且绑定端口号
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        // local.sin_addr.s_addr=inet_addr(c_str(_ip));
        local.sin_port = htons(_port);
        inet_aton(_ip.c_str(), &(local.sin_addr));
        socklen_t len = sizeof(local);
        // 绑定套接字
        int n = bind(_listensockfd, (const struct sockaddr *)&local, len);
        if (n < 0)
        {
            cout << "绑定失败,错误码:" << errno << "，错误信息:" << strerror(errno) << endl;
            exit(BINDERROR);
        }
        cout << "绑定成功........." << endl;
        // 将套接字设置为监听状态
        // 因为Tcp是面向字节流的，且是被动的，服务器需要一直打开来接受客户端的请求
        if (listen(_listensockfd, 5) == -1)
        {
            cout << "设置监听失败"
                 << "错误码，" << errno << "错误信息" << strerror(errno) << endl;
            exit(LISTENERROR);
        }
        cout << "listen has finished......" << endl;
    }
     void Service(int &sockfd, uint16_t &port, char *ip)
    {
        // 测试收到消息显示出来,
        char buffer[1024];
        // 读取消息
        while (true)
        {

            ssize_t n = read(sockfd, buffer, sizeof(buffer));
            fflush(stdin);
            if (n > 0)
            {
                buffer[n] = 0;
                cout << "收到来自 ip:" << ip << "端口号：" << port << "的消息:" << buffer << endl;
                // 写回消息，发送消息
                string inputbuffer = "server recive message";
                inputbuffer += buffer;
                write(sockfd, inputbuffer.c_str(), inputbuffer.size());
            }
            else
            {
                cerr << "信息读取错误，错误码" << errno << "，错误信息" << strerror(errno) << endl;
                break;
            }
        }
    }
    static void *Running(void *args)
    {
        PthreadData*data=static_cast<PthreadData*> (args);
        pthread_detach(pthread_self());
        data->_server->Service(data->_newsockfd, data->_clientport, (char*)(data->_clientip).c_str());
       //这里不能关闭描述符
        delete data;
        return nullptr;
    }
    void Start()
    {
        while (true)
        {
            cout << "server is running....." << endl;
            sleep(1);
            // 由于参数为输出型参数，需要给一个sockaddrin来保存客户端的信息
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            // 获取新连接
            int newsockfd = accept(_listensockfd, (struct sockaddr *)&client, &len); // 阻塞式等待
            // 对于这两个套接字  ，—listensockfd，可以理解为拉拢客户端 newsockfd，理解为处理客户端
            // 之前的监听套接字不是我们真正要去处理客户端的套接字 ，只有在accept之后获取的新套接字才是
            if (newsockfd < 0) // 客户端会有很多，accept失败继续去accept
            {
                cout << "accept error" << endl;
                continue;
            }

            uint16_t clientport = htons(client.sin_port);
            char clientip[80];
            // 转为char*
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
            // 根据新连接通信
            cout << "get a new link.....,"
                 << "端口号: " << clientport << "ip :" << clientip << endl;

            // 通过newsockfd进行通信

            // 提供服务
            // Service(newsockfd, clientport, clientip);
            // close(newsockfd);
            // 修改为多进程版

            // pid_t id = fork();
            // if (id == 0)
            // {
            //     close(_listensockfd);
            //     // 子进程
            //     if(fork()>0)
            //     {
            //         //当前进程直接退出
            //         exit(0);
            //     }
            //     //孙子进程来执行service
            //     //我直接退出，孙子进程交给系统领养就可以并发访问了。
            //     Service(newsockfd, clientport, clientip);
            //     close(newsockfd);
            //     exit(0);
            // }
            // close(newsockfd);//这里注意需要关闭 子进程已经拿去用了，如果不关，父进程的文件描述符越来越少
            // //这里其实也并不会关闭，里面有引用计数
            // // 父进程
            // pid_t rid = waitpid(id, nullptr,0);//子进程是阻塞等待，但父进程我们要求继续运行，这里等待设置为
            // (void)rid;
            //但是创建进程消耗太大，还是不是很好，因此我们用线程来执行
            pthread_t tid;
            PthreadData *data=new PthreadData(newsockfd,clientip,clientport,this);
            pthread_create(&tid, nullptr,Running,data);
            //我们不想让它直接等待，而是自己去玩自己的，设置detach
        }
    }

private:
    int _listensockfd;
    uint16_t _port;
    string _ip;
};

main.cc

#include<iostream>
#include<memory>
#include <unistd.h>
#include"Tcpserver.hpp"


void Helper(char *str)
{
    cout<<"please enter command in correct :"<<str<<" port[1024+]."<<endl;
}
int main(int argc,char*argv[])
{
    if(argc!=2)
    {
        Helper(argv[0]);
        exit(1);
    }
    uint16_t port=atoi(argv[1]);
    std::unique_ptr <TcpServer> svr(new TcpServer(port));
    svr->Init();
    svr->Start();
}

Tcpclient.cc

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
using namespace std;

void Helper(char *s)
{
    cout<<"please enter in coorrct command"<<s<<" port[1024+],"<<" ip(0.0.0.0)"<<endl;
}
int main(int argc,char *argv[])
{

    if(argc!=3)
    {
        Helper(argv[0]);
        exit(1);
    }

    uint16_t serverport=stoi(argv[1]);
    string serverip=string(argv[2]);

    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        cerr<<"Error,创建套接字错误"<<endl;
        return 1;
    }
    //不需要显示绑定，系统给绑定了,会在我们connect发起连接后，自动随机绑定

    //发起连接
    //通过命令行参数获取ip地址与端口号
    struct sockaddr_in server;
    bzero(&server, sizeof(server));
    server.sin_family=AF_INET;
    inet_pton(AF_INET,serverip.c_str(),&server.sin_addr);
    server.sin_port=htons(serverport);
    socklen_t len=sizeof(server);
    int n=connect(sockfd,(const struct sockaddr*)&server,len);
    if(n<0)
    {
        cerr<<"Error,连接失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
        return 2;
    }
    cout<<"连接成功......"<<endl;

    //发消息
    while(true)
    {
        string message;
        cout<<"please enter#"<<endl;
        getline(cin,message);
        //将消息写入文件中
        write(sockfd,message.c_str(),message.size());
        //写完消息，再接受来自服务端的消息

        char buf[1024];
        int n=read(sockfd,buf,sizeof(buf));
        if(n<0)
        {
            cerr<<"接收消息失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
        }else{
            buf[n]=0;
            cout<<"port :"<<serverport<<" ip:"<<serverip<<"recive:"<<buf<<endl;
        }
        

    }

    close(sockfd);

    return 0;


}

这里的多线程也不是最好的，因为可能存在多线程，少资源的情况，这里最后直接把线程池拿过来，我需要几个线程就创造几个线程来用。从而效果达到更优。
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.kler.cn/a/273402.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

多ip多进程代理的实现方法

多ip多进程代理的实现方法

目录 写在前面 一、背景 二、实现方法 1. 使用多线程处理代理请求 2. 使用多进程处理代理请求 3. 实现多IP代理 三、总结 写在前面 实现多IP多进程代理需要使用Python的多线程和多进程模块。本文将介绍如何使用这些模块来实现多IP多进程代理&#xff0c;并提供相关的代…
阅读更多...
Github 2024-03-18开源项目日报Top10

Github 2024-03-18开源项目日报Top10

根据Github Trendings的统计，今日(2024-03-18统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下： 开发语言项目数量Python项目7TypeScript项目3非开发语言项目1Solidity项目1《Hello 算法》：动画图解、一键运行的数据结构与算法教程 创建周期：476 天协议类型…
阅读更多...
动态规划（蓝桥杯 C++ 题目 代码 注解）

动态规划（蓝桥杯 C++ 题目 代码 注解）

目录 介绍&#xff1a; 题目一&#xff08;数字三角形&#xff09;&#xff1a; 题目二&#xff08;跳跃&#xff09;&#xff1a; 题目三&#xff08;背包问题类型&#xff09;&#xff1a; 题目四&#xff08;蓝肽子序列&#xff09;&#xff1a; 题目五&#xff08;合唱…
阅读更多...
[TJOI2010] 阅读理解 **STL**Tire树**

[TJOI2010] 阅读理解 **STL**Tire树**

[TJOI2010] 阅读理解 题目链接&#xff1a; https://www.luogu.com.cn/problem/P3879 题目描述 思路1 &#xff08;STL大法&#xff09; 对每个单词&#xff0c;用map来映射存储它所在的短文编号 用set的好处&#xff1a; -------1. 存储直接自动排序&#xff0c;操作简单&…
阅读更多...
003——移植鸿蒙

003——移植鸿蒙

目录 一、顶层Make分析 二、添加一个新的单板 2.1 Kconfig 2.2 Makefile 2.2.1 顶层Makefile 2.2.2 platform下的Makefile 2.2.3 platform下的bsp.mk文件 2.3 编译与调试 2.4 解决链接错误 三、内核启动流程的学习 3.1 韦东山老师总结的启动四步 3.2 启动文件分析…
阅读更多...
Coursera上Golang专项课程3：Concurrency in Go 学习笔记（完结）

Coursera上Golang专项课程3：Concurrency in Go 学习笔记（完结）

Concurrency in Go 本文是 Concurrency in Go 这门课的学习笔记&#xff0c;如有侵权&#xff0c;请联系删除。 文章目录 Concurrency in GoMODULE 1: Why Use Concurrency?Learning Objectives M1.1.1 - Parallel ExecutionM1.1.2 - Von Neumann BottleneckM1.1.3 - Power W…
阅读更多...
LLM 构建Data Multi-Agents 赋能数据分析平台的实践之②：数据治理之一

LLM 构建Data Multi-Agents 赋能数据分析平台的实践之②：数据治理之一

概述 数据治理不仅是产业数字化转型的基石&#xff0c;更是推动产业向更高层次、更精细化、更智能的方向发展的重要引擎。通过科学有效的数据治理实践&#xff0c;产业能够在数字化进程中实现数据驱动的决策与行动&#xff0c;最终达到转型升级的战略目标。 一、数据治理在产业…
阅读更多...
旋转花键的制造工艺

旋转花键的制造工艺

旋转花键的制造工艺是一门精细的技术&#xff0c;涉及多个步骤和精细的操作&#xff0c;以确保最终产品的质量和性能&#xff0c;下面简单介绍下旋转花键的制造工艺。 1、原材料准备&#xff1a;制造旋转花键的核心是选择合适的材料&#xff0c;根据花键的规格和性能要求&#…
阅读更多...
在ubuntu下安装MQTT 服务

在ubuntu下安装MQTT 服务

ubuntu系统版本22.4.4LTS amd64 在ubuntu系统下打开终端输入命令 ## 安装MQTT 服务 sudo apt-get install mosquitto mosquitto-clients继续执行后系统就完成了安装并默认已启动服务 ## 查看MQTT运行状态 systemctl status mosquitto## 启动服务 systemctl start mosquitto…
阅读更多...
MYSQL日志 redo_log更新流程 bin_log以及bin_log数据恢复

MYSQL日志 redo_log更新流程 bin_log以及bin_log数据恢复

Redo_log写入策略 Redo log的Innodb_flush_log_at_trx_commit:: 这个参数有三个取值 取值为0&#xff1a;每次事务提交时&#xff0c;只是把redo_log留在 redo log buffer中&#xff0c;宕机会丢失数据&#xff1b; 取值为1&#xff08;默认值&#xff09;&#xff1a;每次事…
阅读更多...
STM32CubeIDE基础学习-BEEP蜂鸣器实验

STM32CubeIDE基础学习-BEEP蜂鸣器实验

STM32CubeIDE基础学习-BEEP蜂鸣器实验 文章目录 STM32CubeIDE基础学习-BEEP蜂鸣器实验前言第1章 硬件介绍第2章 工程配置2.1 工程外设配置部分2.2 生成工程代码部分 第3章 代码编写第4章 实验现象总结 前言 前面学习了LED闪烁实验&#xff0c;现在来学习一下蜂鸣器发声实验&am…
阅读更多...
【LabVIEW FPGA入门】并行执行

【LabVIEW FPGA入门】并行执行

利用图形化编程的并行特性以及 FPGA 上 LabVIEW 图的真正并行实现&#xff0c;您可以通过将应用程序代码划分为更小的进程来进一步优化执行速度。与整个应用程序在一个循环中运行相比&#xff0c;这使得每个进程能够实现更高的循环速率和更高的应用程序整体执行速率。 …
阅读更多...
Docker部署TeamCity来完成内部CI、CD流程

Docker部署TeamCity来完成内部CI、CD流程

使用TeamCity来完成内部CI、CD流程 本篇教程主要讲解基于容器服务搭建TeamCity服务&#xff0c;并且完成内部项目的CI流程配置。至于完整的DevOps&#xff0c;我们后续独立探讨。 一个简单的CI、CD流程 以下分享一个简单的CI、CD流程&#xff08;仅供参考&#xff09;&#…
阅读更多...
AJAX-原理XMLHttpRequest

AJAX-原理XMLHttpRequest

定义 使用 查询参数 定义&#xff1a;浏览器提供给服务器的额外信息&#xff0c;让服务器返回浏览器想要的数据 语法&#xff1a;http://xxxx.com/xxx/xxx?参数名1值1&参数名2值2
阅读更多...
yocto编译测试

yocto编译测试

源码下载 git clone -b gatesgarth git://git.yoctoproject.org/poky lkmaolkmao-virtual-machine:~/yocto$ git clone -b gatesgarth git://git.yoctoproject.org/poky Cloning into poky... remote: Enumerating objects: 640690, done. remote: Counting objects: 100% (13…
阅读更多...
部署Zabbix Agents添加使能监测服务器_Windows平台_MSI/Archive模式

部署Zabbix Agents添加使能监测服务器_Windows平台_MSI/Archive模式

Windows平台 一、从MSI安装Windows代理，添加Windows Servers/PC 概述 可以从Windows MSI安装包（32位或64位） 安装Zabbix agent 32位包不能安装在64位Windows中 所有软件包都支持TLS，配置TLS可选 支持UI和命令行的安装。 1、下载Agent代理程序，使用Agent2升级版，官网链接如…
阅读更多...
计算机视觉之三维重建（1）---摄像机几何

计算机视觉之三维重建（1）---摄像机几何

文章目录 一、针孔模型和透镜1.1 针孔摄像机1.2 近轴折射模型1.3 透镜问题 二、摄像机几何2.1 像平面和像素平面2.2 齐次坐标下的投影变换2.3 摄像机倾斜2.4 规范化摄像机2.5 世界坐标系2.6 Faugeras定理2.7 投影变换性质&#xff1a; 三、其他投影摄像机模型3.1 弱透视投影摄像…
阅读更多...
MacOS本地使用Docker Desktop 搭建Minio容器

MacOS本地使用Docker Desktop 搭建Minio容器

1. 下载docker Desktop docker官网&#xff1a;https://www.docker.com/products/docker-desktop/ 根据自己的型号进行选择&#xff0c;我的M系列芯片&#xff0c;选择的是Apple-Chip&#xff0c;记得需要看到最后噢&#xff01; 最后有坑点解决办法&#xff01; 最后有坑点解…
阅读更多...
Zinx框架的高级用法

Zinx框架的高级用法

一、使用框架提供的实用类 zinx框架已经提供了常用的IO通道类-TCP。 阅读Tcp相关类的使用文档&#xff0c;将之前的3个案例用TCP的方式实现。 步骤&#xff1a; 创建Tcp数据通道类继承ZinxTcpData&#xff0c;重写GetInputNextStage函数&#xff0c;内容跟之前标准输入通道类…
阅读更多...
鸿蒙Harmony应用开发—ArkTS声明式开发（绘制组件：Polygon）

鸿蒙Harmony应用开发—ArkTS声明式开发（绘制组件：Polygon）

多边形绘制组件。 说明&#xff1a; 该组件从API Version 7开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 子组件 无 接口 Polygon(value?: {width?: string | number, height?: string | number}) 从API version 9开始&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023