TCP客户端服务器代码

最新推荐文章于 2024-05-06 00:06:21 发布
最新推荐文章于 2024-05-06 00:06:21 发布
阅读量674 收藏 1
点赞数 5
分类专栏： 网络编程 文章标签： tcp/ip 服务器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61567378/article/details/125352953
版权

此TCP服务器客户端使用

  1. 使用了线程池
  2. 解决了粘包问题
  3. 使用了任务类
  4. 使用了方法类

TCPcode

服务器

server.cc

#include"server.hpp"
int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        cout<<"wrong command,please type again"<<endl;
        exit(1);
    }
    TCPSERVER* p=new TCPSERVER(atoi(argv[1]));
    p->InitServer();
    p->StartTcp();
    delete p;
    return 0;
}

server.hpp

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <signal.h>
#include <cstring>
#include <arpa/inet.h>
#include <string>
#include <pthread.h>
#include <cstdlib>
#include "threadpool.hpp"
using namespace ns_threadpool;
using namespace std;
#define MAX 1024
#define DEFUALTPORT 8081
#define BACKLOG 20

//因为我们要获取里面的东西，所以定义称struct类型的就可以了



struct Param
{
    int _sockfd;
    string _ip;
    int _port;
    Param(int sockfd, string ip, int port)
        : _sockfd(sockfd), _ip(ip), _port(port)
    {
    }
    ~Param()
    {
    }
};

//我们在服务端引入了线程池，在服务类里面增加一个线程池的指针成员
class TCPSERVER
{
private:
    int _sockfd; //监听套接字
    int _port;   //服务端的端口号
    ThreadPool<Task> *tp;

public:
    void err(const char *error)
    {
        perror(error);
        exit(1);
    }
    TCPSERVER(int port = DEFUALTPORT)
        : _port(port), _sockfd(-1)
    {
    }
    ~TCPSERVER()
    {
        if (_sockfd > 0)
            close(_sockfd);
    }
    void InitServer()
    {
        signal(SIGCHLD, SIG_IGN); //忽略子进程退出后，给父进程发送的信号
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            err("socket");
        }
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_port = htons(_port);
        local.sin_family = AF_INET;
        local.sin_addr.s_addr = INADDR_ANY;
        if (bind(_sockfd, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            err("bind");
        }
        if (listen(_sockfd, BACKLOG) < 0)
        {
            err("listen");
        }
        tp = new ThreadPool<Task>(); //先动态开辟一个线程池对象
    }
    // static void *Routine(void *args) //因为在类里面，所以不要this指针
    // {
    //     Param sock = *(Param *)args;
    //     delete args;
    //     pthread_detach(pthread_self()); //线程分离就不需要再去join了
    //     cout << "create a new pthread for IO" << endl;
    //     char buff[MAX];
    //     while (true)
    //     {
    //         //读取数据
    //         struct sockaddr_in peer;
    //         socklen_t len = sizeof(peer);
    //         ssize_t s = recvfrom(sock._sockfd, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len); // peer里面就是远程的数据了
    //         if (s > 0)
    //         {
    //             buff[s] = 0;
    //             fflush(stdout);
    //             cout << "#client:" << buff << endl;
    //             string msg = "#client ";
    //             msg += buff;
    //             sendto(sock._sockfd, msg.c_str(), msg.size(), 0, (struct sockaddr *)&peer, len);
    //         }
    //         else
    //         {
    //             cout << "error data" << endl;
    //             break;
    //         }
    //     }
    // }
    void StartTcp()
    {
        tp->InitThreadPool(); //初始化线程池

        while (true)
        {
            sockaddr_in endpoint;
            memset(&endpoint, '\0', sizeof(endpoint));
            //处理任务
            socklen_t len = sizeof(endpoint);
            int sock = accept(_sockfd, (struct sockaddr *)&endpoint, &len); //这个sock就是用来和客户端进行通信的，
            if (sock < 0)
            {
                perror("accept");
                continue;
            }
            string cli_ip = inet_ntoa(endpoint.sin_addr);
            string ip(cli_ip);
            int port = ntohs(endpoint.sin_port);
            cli_ip += ":";
            cli_ip += to_string(ntohs(endpoint.sin_port));
            cout << "get a link->" <<sock<< cli_ip <<"->"<<port<< endl;
            // pthread_t tid;
            //但是调用server函数的时候我们需要的是socket ip port，创建线程的时候只能传一个参数，所以我们需要定义一个结构体存储这些信息
            // Param *p = new Param(sock, ip, port); //这样就把数据都初始化传进去了，三个数据都有了

            //对于主线程accept上来的文件描述符，不能由主线程来close，应该让操作这个sockfd的线程进行关闭
            //同样，新线程也不能对监听sockfd进行关闭
            // pthread_create(&tid, nullptr, Routine, (void *)p); //在这里执行操作，所以这个地方就要传入套接字

            //构造一个任务
            Task task(sock,ip,port);
            //把这个任务放到线程池的任务队列里面取
            tp->PushTask(task);


            /*
                各个线程共享一个文件描述符表，因此当主线程调用accept的时候，其他创建的新线程是可以直接访问到这个文件描述符的
                由于此时新线程并不知道它要服务的客户端所要对应的是哪一个文件描述符，所以此时主线程要告诉新线程应该要去访问的文件描述符的值
                就是要操作哪一个套接字

            */
            /*
            当前多线程版本的服务器存在的问题是，每次有新的链接来的话，就会为客户端创建为它服务的新线程，在服务结束之后就会把他进行销毁，
            这样不仅有麻烦，效率还很低下

            如果有大量的客户端进行连接请求，此时服务端要为每一个客户端创建对应的服务线程，计算机中的线程越多，CPU 的压力也就越大，CPU要在
            这些线程里面不断的来回切换，此时CPU 在调度线程的时候，线程和线程之间的切换成本就很高，线程如果很多的话，被调度的周期也就很长，
            这样客户端也会迟迟得不到应答
            */

            /*
            解决方案
            * 可以先在服务端创建一些线程，当有客户端请求连接的时候 就让这些线程提供服务，此时客户端一来就有线程来替他们服务，而不是客户端请求了才创建线程

            * 当某个线程为客户端提供完服务之后，不要让该线程退出，而是让该线程继续为下一个客户端提供服务，如果当前没有客户端连接请求，则可以让线程先休眠
            当有客户端到来的时候再把该线程唤醒

            * 服务端创建的这一批线程不能太多，此时CPU 的压力也就不会太大，如果此时客户端连接到来，此时一批线程都在进行工作，那么此时服务端不应该再创建线程
            而是让这个新来的线程再连接队列里面排队，等服务端这些线程有空闲的就替它提供服务



            此时就引入了线程池再服务端里面，因为线程池的存在就是为了避免处理短时间任务创建和销毁线程的代价，此时线程池还能够保证内核充分利用，避免过分调度

            其中线程池里面有一个任务队列，当有新的任务来的时候，就把任务push到线程池里面，再线程池里面我们默认创建了5个线程，如果线程池里面没有那么多任务，就休眠



            */
        }
    }
};

threadpool.hpp

#pragma once
#include <iostream>
#include <string>
#include <queue>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include"IO.hpp"
#include <cstring>
using namespace std;
//设计一个handler类，在handler类里面对（）操作符进行重载，将（）操作符的执行动作重载为执行server函数的代码
class Handler
{
public:
    Handler()
    {
    }
    ~Handler()
    {
    }


    void operator()(int sock, string cliip, int cliport)
    {
        //执行server函数的代码
        // char buff[1024];
        // while (true)
        // {
        //     ssize_t size = read(sock, buff, sizeof(buff) - 1);
        //     if (size > 0) //读取成功
        //     {
        //         buff[size] = '\0';
        //         cout << cliip << ":" << cliport << "#" << buff << endl;
        //     }
        //     else if (size == 0) //对端关闭了
        //     {
        //         cout << cliip << ":" << cliip << " close!" << endl;
        //     }
        //     else
        //     {
        //         //读取失败
        //         cerr << sock << " read error!" << endl;
        //         break; //读取失败的化就关闭
        //     }
        // }

        char *buff; //接收数据
        while (true)
        {
            //读取数据
            // struct sockaddr_in peer;
            // socklen_t len = sizeof(peer);
            // ssize_t s = recvfrom(sock, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len); // peer里面就是远程的数据了

            //使用新的解决粘包问题的读取数据的方法
            int s = RecvMsg(sock, &buff); //读取数据
            if (s > 0)
            {
                buff[s] = 0;
                fflush(stdout);
                cout << "#client:" << buff << endl;
                string msg = "#client ";
                msg += buff;
                //发送回客户端
                sendmsg(sock, msg.c_str(), msg.size()); //发送数据
                // sendto(sock, msg.c_str(), msg.size(), 0, (struct sockaddr *)&peer, len);
            }
            else
            {
                cout << "error data" << endl;
                break;
            }
        }

        close(sock); //这个线程用完了就要把这个文件描述符关掉
        cout << cliip << ":" << cliport << " service done!" << endl;
    }
};

class Task //任务
{
private:
    int _sockfd;
    string _cliip;
    int _cliport;
    Handler _handler; //处理方法
public:
    Task() //无参数，就是为了线程池取任务出来执行
    {
    }
    Task(int sock, string ip, int port) //构造函数里面放任务
        : _sockfd(sock), _cliip(ip), _cliport(port)
    {
    }
    ~Task()
    {
    }

    //处理任务的函数
    void Run()
    {
        _handler(_sockfd, _cliip, _cliport); //调用仿函数
    }
};

namespace ns_threadpool
{
    const int g_num = 5;
    template <class T>
    class ThreadPool //线程池
    {

    private:
        int num_;                  //一个线程池里面有多少个任务
        std::queue<T> task_queue_; //任务队列,临界资源
        pthread_mutex_t mtx_;
        pthread_cond_t cond_;

    public:
        ThreadPool(int num = g_num) : num_(num)
        {
            pthread_mutex_init(&mtx_, nullptr);
            pthread_cond_init(&cond_, nullptr);
        }

        ~ThreadPool()
        {
            pthread_mutex_destroy(&mtx_);
            pthread_cond_destroy(&cond_);
        }

        //在类中，要让

        static void *Rountine(void *args)
        //也不能访问类里面非static成员
        {

            pthread_detach(pthread_self()); //实现线程分离就不要再去join等待了
            ThreadPool<T> *tp = (ThreadPool<T> *)args;
            while (true)
            {
                //从任务队列里面去拿一个任务
                //执行任务，要先把这个任务队列锁主

                //每个线程他跟放任务的线程一样，都是竞争式的去拿一个任务
                tp->Lock();
                //先检测任务队列是否有一个任务
                while (tp->IsEmpty())
                {
                    //检测到任务队列为空
                    //此时线程就挂起等待
                    tp->Wait();
                }
                //该任务队列里面一定有任务了
                T t;
                tp->PopTask(&t);
                //任务就拿到了
                tp->UnLock();
                t.Run(); //可能有多个线程在处理任务,

                sleep(1);
            }
        }
        void InitThreadPool()
        {
            //初始化一批线程，
            //这样就不要每次用都要去开辟线程了
            pthread_t tid; //一次创建一批线程
            for (int i = 0; i < num_; i++)
            {
                pthread_create(&tid, nullptr, Rountine, (void *)this);
                //在类中不能执行线程的方法，因为他都有隐藏的this指针
                //所以我们需要使用静态的函数，就没有了this指针
            }
        }
        void PopTask(T *out)
        {
            *out = task_queue_.front();
            task_queue_.pop();
        }
        void Wait()
        {
            pthread_cond_wait(&cond_, &mtx_);
        }
        bool IsEmpty()
        {
            return task_queue_.empty();
        }
        void Lock()
        {
            pthread_mutex_lock(&mtx_);
        }
        void UnLock()
        {
            pthread_mutex_unlock(&mtx_);
        }
        void Wakeup()
        {
            pthread_cond_signal(&cond_);
        }
        void PushTask(const T &in)
        {
            //塞任务，就相当于一个生产者，生产者之间要进行互斥访问
            Lock();
            task_queue_.push(in);
            UnLock();
            Wakeup();
        }

        //万一任务队列里面一个任务都没有的话，那么线程池里面的每一个线程就要处于休眠状态，挂起等待
    };
}

IO.hpp

#pragma once
#include<iostream>
#include<cstdlib>
#include<unistd.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<cstring>
#include<arpa/inet.h>

int writen(int _sockfd,const char *msg, int size)
{
    const char *buf = msg; //指向它的地址，发送出去
    int count = size;      //剩余需要发送的字节数
    while (count > 0)
    {
        int len = send(_sockfd, buf, count, 0);
        if (len == -1)
        {
            //发送失败
            return -1;
        }
        else if (len == 0)
        {
            continue; //没发送出去，再发送一次
        }
        else
        {
            //发送成功
            buf += len;
            count -= len;
        }
    }
    return size; //发送成功，发送完成
}

void sendmsg(int _sockfd,const char *msg, int len)
{
    //先申请包头
    char *data = (char *)malloc(sizeof(char) * (len + 4)); //多加的4是为了数据的长度
    int biglen = htonl(len);
    memcpy(data, &biglen, 4);        //拷贝4个字节过去
    memcpy(data + 4, msg, len);      //拷贝len个长度过去
    int ret = writen(_sockfd,data, len + 4); //真正的传输数据
    if (ret == -1)
    {
        //发送失败
        free(data); //把data的内存销毁掉
        close(_sockfd);
    }
    else
        free(data);
}

int readn(int _sockfd,char *buf, int size)
{
    char *pt = buf;
    int count = size;
    while (count > 0)
    {
        int len = recv(_sockfd, pt, count, 0);
        if (len == -1)
        {
            //读取失败
            return -1;
        }
        else if (len == 0)
        {
            return size - count;
        }
        else
        {
            pt += len;
            count -= len;
        }
    }
    return size;
}
int RecvMsg(int _sockfd,char **buf)
{
    //解包

    int len = 0;
    readn(_sockfd,(char *)&len, 4);
    len = htonl(len);
    char *msg = (char *)malloc(sizeof(char) * (len + 1));
    int size = readn(_sockfd,msg, len);
    if (size != len)
    {
        close(_sockfd);
        free(msg);
        return -1;
    }
    msg[size] = '\0';
    *buf = msg;
    return size;
}

客户端

client.cc

#include"client.hpp"
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        cout<<"please type again"<<endl;
        exit(1);
    }
    TcpClient* cl=new TcpClient(argv[1],atoi(argv[2]));
    cl->InitClient();
    cl->StartClient();
    
    return 0;
}

client.hpp


#pragma once
#include<iostream>
#include<string>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<cstdlib>
#include<arpa/inet.h>
#include<cstring>
#include"IO.hpp"
using namespace std;



class TcpClient
{
    private:
    string _ip;//服务器的ip地址
    int _port;//这里的端口就是服务器的端口
    int _sockfd;//创建socket连接到服务器上面
    public:
    TcpClient(string ip="127.0.0.1",int port=8081)
    :_ip(ip),_port(port)
    {}    
    ~TcpClient()
    {
        if(_sockfd>0)
        {
            close(_sockfd);
        }
    }
    void InitClient()
    {
        _sockfd=socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            perror("socket");
            exit(1);
        }
        struct sockaddr_in svr;//连接到远程服务器上
        svr.sin_port=htons(_port);
        svr.sin_family=AF_INET;
        svr.sin_addr.s_addr=inet_addr(_ip.c_str());//将string转化成为网络字节序
        socklen_t len=sizeof(svr);
        if(connect(_sockfd,(struct sockaddr*)&svr,len)!=0)
        {
            perror("connect");
            exit(1);
        }


    }

    
    void StartClient()
    {
        
      
        while(true)
        {
            string msg;
            getline(cin,msg);
            //这样发送会出现丢包问题,所以我们要进行修改
            sendmsg(_sockfd,msg.c_str(),msg.size());//将msg的数据和大小都发送过去
            
            //发送完之后就要接收数据
            char* buf;//用来接收数据
            int ss=RecvMsg(_sockfd,&buf);      
            if(ss>0)
            {
                buf[ss]=0;
                cout<<"server echo "<<buf<<endl;
            }
            
            //发送数据



        }
    }
};
Zevin~
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
C/Linux网络编程V——TCP客户端代码实现
weixin_46345928的博客
03-30 489
上次实现了服务器端的代码，这次实现客户端的代码。
《网络编程》C语言 创建TCP服务器（三种）
qq_60071225的博客
08-15 2175
利用Linux创建TCP三种服务器：循环服务器、多进程并发服务器、多线程并发服务器及其伪代码
TCP（TCP客户端、服务器如何通信）
最新发布
BEIFEN13的博客
05-06 4923
TCP客户端、服务器如何通信，讲解了bind,listen,accept 等函数，与UDP的差别等等
Windows下TCP编程——服务器客户端代码以及爬虫示例
AAAA202012的博客
10-20 2013
为什么Ieee浏览器能显示网站的照片等数据呢，是因为浏览器(客户端)给这个网站（服务器）发了一个请求，请求他的数据给我，这个网站服务器就将它的数据就发到我的这个Ieee上来，当然也能发到我写的程序。个人电脑上打了一个网址(www.xxxxxx),IE会生成一段码流(http协议的格式)，服务器将请求的结果(网页源代码)返回给IE，IE拿了源代码之后，根据其中的链接，再去各服务器获取图片内容。而我们的爬虫就是模拟IEEE生成一段码流，发送给服务器我们的请求，服务器将请求的结果返回。
TCP服务端和客户端实例代码
hhaijiuwo的博客
07-08 1273
1、TCP服务器 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<unistd.h> #include<arpa/inet.h> #include<sys/socket.h> void error_handling(char * message) { fputs(message, stderr); fputc(’\n’, stderr); exit(1);
【Linux】来写一个tcp的服务端+客户端
慕雪华年的博客
04-17 2136
title: 【Linux】来写一个tcp的服务端+客户端今天让我们来写一个tcp的服务器/客户端代码more完整代码见我的gitee阅读本文前，建议先阅读👉。
TCP客户端代码编写
qq_42303254的博客
08-16 151
C# TCP客户端源代码
09-07
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Net; using System.Net.Sockets;... }
Tcp客户端服务器
06-01
开发环境Vs2012,语言C# 内容：TCP心跳服务器、数据服务器登录和通讯框架。XP、win7 32位、64位系统测试通过。 详细描述： 该框架源于CSDN的心跳服务器框架，对其做了修改，增加了数据服务器部分及短连接请求部分。 ...
tcp客户端和服务器.rar
04-24
在这个"tcp客户端和服务器.rar"压缩包中，包含了实现TCP协议客户端和服务器功能的程序，这些程序可以帮助我们理解TCP通信的工作原理。 首先，我们要明白TCP客户端和服务器的角色。服务器通常是一个等待连接请求的...
tcp客户端服务器发送源码
05-08
对于初学者，理解并编写TCP客户端服务器代码是学习网络编程的重要步骤。而对经验丰富的开发者，这可能是一个实现特定功能，如文件传输、实时聊天或在线游戏的基础。 总之，TCP客户端服务器发送源码涉及了网络编程的...
Modbus TCP客户端和服务器示例
09-12
基于我们开源的Modbus协议栈实现的Modbus TCP客户端和服务器示例，使用VS2019开发。
Qt网络编程——TCP 服务器 客户端 代码
04-20
详见：https://blog.csdn.net/weixin_38566632/article/details/124289573 Qt网络编程——TCP 1. 概念 2. 服务器 3. 客户端 4. TCP服务器和客户端互传文件
TCP服务端例程代码
m0_71082338的博客
03-12 146
int i, n;break;for (i = 0;i < n;i++) {return 0;试试看！
TCP协议服务端与客户端
Meryl00的博客
06-27 7055
TCP协议的简单介绍，文中提供服务端与客户端的简单实例。
【代码积累】TCP client
sinat_36263171的博客
06-15 317
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Inet4Address; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socke
TCP服务器代码
酒庄熊人胆
10-17 4948
这两天在看网络编程，写了点程序，发给大家看看. 首先看看流程： 然后直接上代码： #include &amp;amp;amp;lt;Windows.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; using namespace std; #define SERVER_IP &amp;amp;quot;192.168.0.168&amp;amp;quot; //本地UD
tcp服务器源代码
weixin_33717298的博客
08-14 365
package com.zy; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Serv...
TCP服务器代码讲解
weixin_46098612的博客
02-16 1238
本人手撕一段，很多地方没有判断清楚，不利于调试 /* ************************************************************************ * Filename: 01tcp_server.c * Description: * Version: 1.0 * Created: 2019骞?2鏈?2鏃?10鏃?2鍒?7绉? * Revision: none *

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zevin~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值