面向对象的select网络模型加上防止粘包、根据数据头所提供的长度进行接收发数据

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

数据包格式

#ifndef _MessageHeader_hpp_
#define _MessageHeader_hpp_

enum CMD{

    CMD_LOGIN,
    CMD_LOGIN_RESULT,
    CMD_LOGOUT,
    CMD_LOGOUT_RESULT,
    CMD_NEW_USER_JOIN,
    CMD_ERROR
};

//文件头
struct DataHeader{

    short cmd;
    short dataLength;

};
//登录
struct Login :public DataHeader
{
    Login(){
        dataLength = sizeof(Login);
        cmd = CMD_LOGIN;
    }

    char username[32];
    char password[32];
};
//登录结果
struct LoginResult :public DataHeader {

    LoginResult(){
        dataLength = sizeof(LoginResult);
        cmd = CMD_LOGIN_RESULT;
        result = 1;
    }
    int result;

};
//退出
struct Logout :public DataHeader{

    Logout(){
        dataLength = sizeof(Logout);
        cmd = CMD_LOGOUT;
    }
    char userName[32];
};
//退出结果
struct LogoutResult :public DataHeader{

    LogoutResult(){
        dataLength = sizeof(LogoutResult);
        cmd = CMD_LOGOUT_RESULT;
        result = 1;
    }
    int result;
    char data[1024];

};
//新用户加入
struct NewUserJoin :public DataHeader{

    NewUserJoin(){
        dataLength = sizeof(NewUserJoin);
        cmd = CMD_NEW_USER_JOIN;
        scok = 0;
    }
    int scok;

};
#endif

 

client端：主要改进在接收数据的函数


#ifndef _easyClient_hpp_
#define _easyClient_hpp_

#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS
#include<windows.h>
#include<WinSock2.h>
#pragma comment(lib,"ws2_32.lib")//动态链接库
#include<iostream>
#include<stdio.h>
#include<thread>
#include "MH.h"

// 利用當地的消息緩存區來將存储接收的消息，先将消息的头部存储，然后通过对消息长度的提取，提取出消息。
//进而处理消息。处理粘包，将发送的消息分离开来

class easyClient
{
    SOCKET sock;
public:
    easyClient()
    {
        sock = INVALID_SOCKET;
    }
    //虚析构函数
    virtual ~easyClient()
    {
        Close();
    }
    //初始化socket
    void InitSocket(){
        //启动winsock2.x环境
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
        if (sock != INVALID_SOCKET){
            printf("<SOCKET=%d>关闭旧连接", sock);
            Close();
        }
        //1、建立socket
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);


    }

    int Connect(char* ip, unsigned short port){
        if (sock == INVALID_SOCKET){
            InitSocket();
        }

        // 2、连接服务器
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(port);//host to net unsigned short
        _sin.sin_addr.S_un.S_addr = inet_addr(ip);
        int ret = connect(sock, (sockaddr*)&_sin, sizeof(sockaddr_in));
        if (SOCKET_ERROR == ret)
            std::printf("绑定网络端口失败。。。");
        return ret;
    }

    //关闭socket
    void Close(){

        //关闭winsock 2.x环境
        if (sock != INVALID_SOCKET){
            closesocket(sock);
            WSACleanup();
            sock = INVALID_SOCKET;
        }

    }

    //处理网络消息
    bool  OnRun(){

        if (isRun()){
            fd_set fdReader;
            FD_ZERO(&fdReader);
            FD_SET(sock, &fdReader);
            timeval t = { 1, 0 };

            int ret = select(sock, &fdReader, 0, 0, NULL);
            if (ret < 0){
                std::printf("<SOCKET=%d>select 任务结束1\n", sock);
                return false;
            }

            if (FD_ISSET(sock, &fdReader)){

                FD_CLR(sock, &fdReader);

                if (-1 == RecvData(sock)){
                    std::printf("<SOCKET=%d>select 任务结束2\n", sock);
                    return false;
                }
            }
            return true;
        }
        return false;

    }
    //缓冲区最小单元大小
   #define RECV_BUFF_SIZE 1024
    //接收缓冲区
    char _szRecv[RECV_BUFF_SIZE] ;

    //第二缓冲区
    //char _szMagBuf[RECV_BUFF_SIZE * 10] = {};
    char _szMagBuf[10240] ;


    //消息缓冲区尾部位置
    int _lastPos = 0;
    //接收消息，处理粘包
    int RecvData(SOCKET cSocket){

    
        //5、接收客户端请求数据

        int nLen = recv(cSocket, _szRecv, RECV_BUFF_SIZE, 0);
        //当前消息长度
        DataHeader* header = (DataHeader*)_szRecv;
        if (nLen <= 0){
            std::printf("与服务器断开连接，任务结束。\n", cSocket);
            return -1;
        }
        //将接收到的消息拷贝到当地的消息缓冲区
        memcpy(_szMagBuf+_lastPos, _szRecv, nLen);
        //消息缓冲区的数据尾部位置后移
        _lastPos += nLen;

        //消息缓冲区是否大于消息头长度
        while (_lastPos >= sizeof(DataHeader)){
            //消息的长度
            DataHeader* header = (DataHeader*)_szRecv;
            if (_lastPos > header->dataLength){

                //未处理消息缓冲区的长度
                int nSize = _lastPos - header->dataLength;
                //处理网络消息
                OnNetMag(cSocket,header);
                //将消息缓冲区剩余未处理数据前移
                memcpy(_szMagBuf, _szMagBuf + header->dataLength, nSize);
                //消息的尾部位置前移
                _lastPos = nSize;
            }
            else{
                //消息缓冲区剩余数据不够一条完整的消息
                break;
            }
        }

 

        //recv(_cSocket, _szRecv + sizeof(DataHeader), header->dataLength - sizeof(DataHeader), 0);

        //OnNetMag(_cSocket, header);

        return 0;

    }

    //响应网络消息
    void OnNetMag(SOCKET _cSocket, DataHeader* header){
        //6、处理请求

        switch (header->cmd){
        case CMD_LOGIN_RESULT: {

                                   LoginResult* login = (LoginResult*)header;
                                   std::printf("收到服务器=%d消息：CMD_LOGIN_RESULT，数据长度:%d  \n", _cSocket, header->dataLength);

 

        } break;
        case CMD_LOGOUT_RESULT:{

                                   LogoutResult* logout = (LogoutResult*)header;
                                   std::printf("收到服务器=%d消息：CMD_LOGOUT_RESULT，数据长度:%d  \n", _cSocket, header->dataLength);

 

        }break;
        case CMD_NEW_USER_JOIN:{

                                   NewUserJoin* userjoin = (NewUserJoin*)header;
                                   std::printf("收到服务器=%d消息：CMD__NEW_USER_JOIN,新用户加入\n", _cSocket);


        } break;
        case CMD_ERROR:
        {
                          printf("<Socket=%d>收到服务端消息：CMD_ERROR，数据长度：%d\n", _cSocket, header->dataLength);

        }break;
        default:{
                    printf("<Socket=%d>收到服务端未定义消息，数据长度：%d\n", _cSocket, header->dataLength);
        }

        }
        std::printf("发送成功\n");

    }
    //发送网络消息
    int SendData(DataHeader* header){
        if (isRun() && header){
            return send(sock, (const char*)header, header->dataLength, 0);
        }
        return INVALID_SOCKET;
    }


    //是否工作中
    bool isRun(){
        return sock != INVALID_SOCKET;
    }
private:

 

};
#endif

client端的main.cpp

主函数：

 

#include<iostream>
#include<stdio.h>
#include<thread>
#include "client1.h"
#include"MH.h"
using namespace std;

 


// 利用當地的消息緩存區來將存储接收的消息，先将消息的头部存储，然后通过对消息长度的提取，提取出消息。
//进而处理消息。处理粘包，将发送的消息分离开来


bool g_bRun = true;
void cmdThread()
{
    while (true){

        char cmdBuf[256] = {};
        scanf("%s", cmdBuf);
        if (0 == strcmp(cmdBuf, "exit")){
    
            std::printf("退出thread线程\n");
            break;
        }
        
        else{
            printf("不支持的命令\n");
        }
    }

 

}

int main(){
    const int ncount = 10;
    easyClient* client[ncount];
    
    for (int n = 0; n < ncount; n++){
        client[n] = new easyClient();
        client[n]->Connect("127.0.0.1", 4567);
    }
    //启动线程

    thread t1(cmdThread);
    t1.detach();

    Login login;
    strcpy(login.username, "lyd");
    strcpy(login.password, "123");

    while (g_bRun){
        for (int n = 0; n < ncount; n++){
            client[n]->SendData(&login);
        }


    }
    for (int n = 0; n < ncount; n++){

        client[n]->Close();
        delete client[n];
    }
    

 

    std::printf("已退出\n");
    std::system("pause");

    return 0;
}

 

server端：

//将接受的client端封装到ClientSocket中，对client的对象进行处理。

//注意：因为栈内存很小，所以在生成对象的时候，最好使用指针来完成。指针指向实际对象存储在堆内存上。

#ifndef _servers_hpp_
#define _servers_hpp_

#define WIN32_LEAN_AND_MEAN
#define _CRT_SECURE_NO_WARNINGS
#include<windows.h>
#include<WinSock2.h>
#include<iostream>
#include<vector>
#include"MH.h"
#pragma comment(lib,"ws2_32.lib")//动态链接库
//可以在属性的链接库中添加
//using namespace std;

 

// 利用當地的消息緩存區來將存储接收的消息，先将消息的头部存储，然后通过对消息长度的提取，提取出消息。
//进而处理消息。处理粘包，将发送的消息分离开来


#define RECV_BUFF_SIZE 1024
//class ClientSocket,纪录每个链接服务器的客户端
    
class ClientSocket{
public:

    ClientSocket(SOCKET sockfd=INVALID_SOCKET){
        _sockfd = sockfd;
        memset(_szMagBuf, 0, sizeof(_szMagBuf));
        _lastPos = 0;
    }
    SOCKET sockfd(){

        return _sockfd;
    }
    char* msgBuf(){

        return _szMagBuf;
    }

    int getLastPos(){
        return _lastPos;
    }

    void setLastPos(int pos){
        
        _lastPos = pos;
    }
private:
    SOCKET _sockfd;


    //第二缓冲区  消息缓冲区
    char _szMagBuf[RECV_BUFF_SIZE * 10];

    //char _szMagBuf[2048] = {};
    //消息缓冲区尾部位置
    int _lastPos ;
};

 

// new 堆内存
// int a=0; 栈上面
class servers{

private:
    std::vector<ClientSocket*> g_clients;

    SOCKET sock;

public:
    servers(){
        sock = INVALID_SOCKET;
    }

    virtual ~servers(){

        Close();
    }

    //初始化Socket
    SOCKET InitSocket(){

        //启动winsock2.x环境
        WORD ver = MAKEWORD(2, 2);
        WSADATA dat;
        WSAStartup(ver, &dat);
        if (sock != INVALID_SOCKET){
            printf("<SOCKET=%d>关闭旧连接", sock);
            Close();
        }
        //1、建立socket
       sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        return sock;
    }

    //绑定端口号
    int Bind(const char* ip, unsigned short port){

        if (sock == INVALID_SOCKET){
            InitSocket();
        }
        // 2、绑定网络端口
        sockaddr_in _sin = {};
        _sin.sin_family = AF_INET;
        _sin.sin_port = htons(port);//host to net unsigned short
        _sin.sin_addr.S_un.S_addr = inet_addr(ip);

        int ret = bind(sock, (sockaddr*)&_sin, sizeof(sockaddr_in));

        if (SOCKET_ERROR == ret)
            printf("绑定网络端口失败。。。");

        return ret;

 

    }


    //监听端口号
    int Listen(int n){

        //3、listen 监听端口
        int ret = listen(sock, n);
        if (SOCKET_ERROR == ret)
            printf("<SOCKET=%d>监听网络端口失败。。。", sock);

        return ret;
    }

 

    //接收客户端连接
    SOCKET Accept(){
        //4、accept 等待客户端连接
        sockaddr_in clientAddr = {};
        int nAddrlen = sizeof(sockaddr_in);
        SOCKET _cSocket = INVALID_SOCKET;

        _cSocket = accept(sock, (sockaddr*)&clientAddr, &nAddrlen);

        if (INVALID_SOCKET == _cSocket){
            printf("<SOCKET=%d>错误，接收到无效客户端。。。\n", (int)_cSocket);
        }
        else
        {
            NewUserJoin userjoin;
            SendDataToAll(&userjoin);
            g_clients.push_back(new ClientSocket(_cSocket));

            printf("新客户端加入：socket=%d,IP=%s\n", (int)_cSocket, inet_ntoa(clientAddr.sin_addr));

        }
        return _cSocket;
    }

    //关闭socket
    void Close(){

        //关闭winsock 2.x环境
        if (sock != INVALID_SOCKET){
            for (int n = (int)g_clients.size() - 1; n >= 0; n--){
                closesocket(g_clients[n]->sockfd());
                delete g_clients[n];
            }

            // 7、关闭服务端套接字
            closesocket(sock);
            WSACleanup();
            sock = INVALID_SOCKET;
        }

    }


    

    //处理网络消息
    bool OnRun(){
        if (isRun()){

            fd_set fdRead;
            fd_set fdWrite;
            fd_set fdExp;

            //清理集合
            FD_ZERO(&fdRead);
            FD_ZERO(&fdWrite);
            FD_ZERO(&fdExp);

            //加入集合
            FD_SET(sock, &fdRead);
            FD_SET(sock, &fdWrite);
            FD_SET(sock, &fdExp);

            SOCKET maxSock = sock;
            for (int n = (int)g_clients.size() - 1; n >= 0; n--){
                //判断集合是否在集合中
                FD_SET(g_clients[n]->sockfd(), &fdRead);
                if (maxSock < g_clients[n]->sockfd())
                    maxSock = g_clients[n]->sockfd();
            }
            timeval t = { 1, 0 };
            int ret = select(sock + 1, &fdRead, &fdWrite, &fdExp, &t);
            if (ret < 0){
                printf("select 客户端已退出。。。\n");
                Close();
                return false;
            }

            if (FD_ISSET(sock, &fdRead)){

                FD_CLR(sock, &fdRead);
                Accept();
            }

 

            for (int n = (int)g_clients.size() - 1; n >= 0; n--)
            {
                if (FD_ISSET(g_clients[n]->sockfd(), &fdRead)){
                    {
                        if (-1 == RecvData(g_clients[n]))
                        {
                            //auto iter = find(g_clients.begin(), g_clients.end(), fdRead.fd_array[n]);
                            auto iter = g_clients.begin() + 1;
                            if (iter != g_clients.end())
                            {
                                delete g_clients[n];
                                g_clients.erase(iter);
                            }
                        }
                    }
                }

            }
            return true;
        }

        else{
            return false;
        }
    }
    //发送指定socket网络消息
    int SendData(SOCKET _cSocket, DataHeader* header){
        if (isRun() && header){
            return send(_cSocket, (const char*)header, header->dataLength, 0);
        }
        return INVALID_SOCKET;
    }

    //发送指定socket网络消息
    void SendDataToAll(DataHeader* header){

        if (isRun() && header){
            for (int n = (int)g_clients.size() - 1; n >= 0; n--){
                SendData(g_clients[n]->sockfd(), header);
            }
        }

    }

    //是否工作中
    bool isRun(){
        return sock != INVALID_SOCKET;
    }


    //消息缓冲区
    char _szRecv[RECV_BUFF_SIZE] ;
    //接收消息，处理粘包
    int RecvData(ClientSocket* pClient){
    
        //5、接收客户端请求数据

        int nLen = recv(pClient->sockfd(), _szRecv, RECV_BUFF_SIZE, 0);

        
        if (nLen <= 0){
            std::printf("客户端<SOCKET=%d>已退出\n", pClient->sockfd());
            return -1;
        }

        //将接收到的消息拷贝到当地的消息缓冲区
        memcpy(pClient->msgBuf() + pClient->getLastPos(), _szRecv, nLen);

        //消息缓冲区的数据尾部位置后移
        pClient->setLastPos(pClient->getLastPos() + nLen);


        //消息缓冲区是否大于消息头长度
        while (pClient->getLastPos() >= sizeof(DataHeader)){

            //消息的长度
            DataHeader* header = (DataHeader*)pClient->msgBuf();

            //收到消息大于消息头，开始处理数据
            if (pClient->getLastPos() > header->dataLength){

                //未处理消息缓冲区的长度
                int nSize = pClient->getLastPos() - header->dataLength;
                //处理网络消息
                OnNetMag(pClient->sockfd(), header);
                //将消息缓冲区剩余未处理数据前移
                memcpy(pClient->msgBuf(), pClient->msgBuf() + header->dataLength, nSize);
                //消息的尾部位置前移
                pClient->setLastPos(nSize);
            }
            else{
                //消息缓冲区剩余数据不够一条完整的消息
                break;
            }
        }


    
        return 1;

    }

    //响应网络消息
    virtual void OnNetMag(SOCKET _cSocket, DataHeader* header){

        switch (header->cmd){
        case CMD_LOGIN: {


                            Login* login = (Login*)header;
                            std::printf("收到<SOCKET=%d>命令：CMD_LOGIN，数据长度:%d ,username:%s password:%s \n", _cSocket, login->dataLength, login->username, login->password);

                            std::printf("姓名为：%s上线了。。。\n", login->username);

                            LoginResult ret;
                            SendData(_cSocket, (DataHeader*)&ret);

        }break;

        case CMD_LOGOUT:{


                            Logout* logout = (Logout*)header;
                            std::printf("收到<SOCKET=%d>命令：CMD_LOGOUT，数据长度:%d  username:%s \n", _cSocket, logout->dataLength, logout->userName);

                            std::printf("姓名为：%s 已下线。。。\n", logout->userName);

                            LogoutResult ret;
                            SendData(_cSocket, (DataHeader*)&ret);


        }
            break;

        default:
        {    
                   printf("<Socket=%d>收到未定义消息，数据长度：%d\n", _cSocket, header->dataLength);
                   DataHeader header ;
                   SendData(_cSocket, &header);
        }
            break;

        }

 

        std::printf("发送成功\n");
    }

 

};

 

#endif

 

server的main.cpp

主函数


#include<iostream>
#include"server1.h"
#include<thread>

 

// 利用當地的消息緩存區來將存储接收的消息，先将消息的头部存储，然后通过对消息长度的提取，提取出消息。
//进而处理消息。处理粘包，将发送的消息分离开来


bool g_bRun = true;
void cmdThread(){
    while (true){
        char cmdBuf[256] = {};
        scanf("%s", cmdBuf);
        if (0 == strcmp(cmdBuf, "exit")){
            g_bRun = false;
            printf("退出cmdThread服务器\n");
            break;
        }
        else{
            printf("不支持的命令\n");
        }
    }
}


int main01(){

    servers server;
    server.InitSocket();
    server.Bind("127.0.0.1", 4567);
    server.Listen(5);


    while (g_bRun){

        server.OnRun();

    }
    server.Close();

 

    printf("已退出，任务结束");
    system("pause");
    return 0;
}

 

 

 

 

 

 

holidaywu
关注
专栏目录
【C/C++ 软件开发模拟面试 集】socket 通讯 相关知识点模拟面试
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-21 129
【C/C++ 软件开发模拟面试 集】socket 通讯 相关知识点模拟面试
Java 网络协议面试题答案整理，最新面试题
Miss_SunHengYang的博客
07-15 1163
UDP头部的长度字段是16位的，最大可以表示的数值是65535，但是需要从中扣除UDP头部本身的长度（8字节），因此，理论上UDP数据包的最大长度是65527字节（65535-8）。接收方计算收到的数据包的校验和，如果计算结果与数据包中的校验和不符，说明数据在传输中被损坏，接收方不会发送ACK，发送方在超时后会重传该数据包。当发送方接收到三个连续的重复确认（Duplicate ACKs），即接收方收到一个失序的数据包时，它会立即重传未被确认的数据包，而不是等待重传计时器到期。广播通常在单个网络段内使用。
多线程服务器端程序（支持多台客户端建立连接并向所有客户端转发收到的消息）
11-11
用java编写，运用socket套接字编程，支持多台客户端建立连接并向所有客户端转发收到的消息
TCP 粘包问题以及解决
wwxy1995的博客
07-08 207
如果发送端数据发送过块，接收端的数据接受过慢，接受端TCP内部的缓存区域会溢出，无法再发送数据，造成网络阻塞。 所以每次要尽可能的把缓冲区数据读出来，而不是每次读一条消息头。 因此要在应用层设置第二缓冲区，再从第二缓冲区读数据，拆分包 完整图片说明 //缓冲区 char _szRecv[RECV_BUFF_SZIE] = {}; //接收数据 处理粘包 拆分包 ...
多线程服务器
qq_43108252的博客
02-25 1220
1.thread库的简单介绍 thread库介绍： 头文件： #include<thread> 基本API： //创建一个新线程来执行 run 函数： thread t(run); //实例化一个线程对象t，让该线程执行run函数，构造对象后线程就开始执行了 //假如说 run 函数需要传入参数 a 和 b，我们可以这样构造： thread t(run,a,b); //实例化一个线程对象t，让该线程执行run函数，传入a和b作为run的参数 //需要注意的是，传入的函数必须是全局函
计网简简单单复习一下
最新发布
weixin_43739821的博客
09-11 1133
计算机网络基础 HTTP TCP IP ARP PING WebSocket 网络攻击 CDN 跨域
C++ 网络编程
weixin_44585214的博客
05-20 1235
当服务端收到客户端发送的SYN包后，该连接处于半打开状态。半连接队列（SYN队列）用来存储半打开状态的连接→通过哈希表实现→以O(1)的时间复杂度移除元素。当服务端收到客户端的ACK包后，连接建立成功，先将该连接从半连接队列中移除，然后把该连接加入到全连接队列（accept队列）中。如果客户端收到SYN-ACK包后，不回复ACK包：也就是攻击者短时间伪造不同IP地址的SYN包，快速占满SYN队列，使服务端不能为正常用户服务 → SYN泛洪、SYN攻击、DDos攻击。
C++教程网视频：linux网络编程
05-15
以上是针对《C++教程网视频：Linux网络编程》所涉及的知识点进行了详细的总结。该教程涵盖了从TCP/IP基础知识到高级的网络编程技巧，以及进程间通信和多线程编程等内容，旨在帮助学习者全面掌握Linux环境下的...
多线程服务器通信
03-18
实现多线程的服务器与客户机通信，对应自己的博客https://blog.csdn.net/weixin_43732570/article/details/88633454
java（简易）多线程HTTP服务器
06-09
基于java线程池、java Socket实现了一个简单的多线程Http服务器，可以实现GET资源获取功能、GET表单提交功能，POST 表单提交功能、单文件上传功能。
多进程服务器，多线程服务器
sakura0908的博客
03-19 323
/每次一个新的客户端连接上来，开启一条线程，接收 客户端的数据 25 pthread_create(,,routine,&newClientFd);//捕捉 SIGCHLD信号 执行 信号响应函数，在该函数中 回收子进程。//创建一个子进程，子进程负责接收每一个连接上来的客户端数据。//子进程退出的时候 ，会自动发出来一个SIGCHLD信号。while(1){ //接收 客户端的数据。else if(id >0) //父进程。if(id == 0) //子进程{//接收 客户端的数据。
多线程服务器端的实现
weixin_45767431的博客
11-17 477
本文对多线程以及多线程服务器端的实现做了总结
多线程并发服务器
weixin_BESTWISHES0120的博客
03-28 758
在一个线程中调用pthread_create()创建新的线程后，当前线程从pthread_create()返回继续往下执行，而新的线程所执行的代码由我们传给pthread_create的函数指针start_routine决定。start_routine函数接收一个参数，是通过pthread_create的arg参数传递给它的，该参数的类型为void *，这个指针按什么类型解释由调用者自己定义。同时拥有两个或者多个线程，如果程序在单核处理器上运行，多个线程将交替的换入或者换出内存，这些线程是同时“存在”的。
多线程网络服务
weixin_34260991的博客
09-23 109
1、多线程网络服务 ：多线程网络模式类似于多进程网络模式；不同的是：新客户端到来时，启动的是一个线程(每来一个客户，将创建一个线程)。模型分析2、代码实现同样用处理整数运算来模拟多线程的并发处理(1)、utili.h#include<unistd.h> #include<stdio.h> #include<string.h> #inclu...
一个简单的Linux多线程服务器
dblinux
11-01 343
Linux多线程 1. Linux多线程并发服务器模型 ​ 在Linux多线程服务端编程时，首先还是之前的三步走????（创建socket、bind绑定地址与端口号、listen设置最大监听上限）。重要的是线程回调函数和循环里面的逻辑。下面给出该步骤： 2. 线程知识回顾 线程是程序中完成一个独立任务的完整执行序列，即一个可调度的实体。 线程创建????‍♀： #include <pthread.h> int pthread_create(pthread_t* thread, con
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值