C 语言并发服务实现

最新推荐文章于 2024-05-14 23:13:17 发布
最新推荐文章于 2024-05-14 23:13:17 发布
阅读量129 收藏
点赞数 3
文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40154354/article/details/138301976
版权

        这个文档描述了一个本人在 15 年前的后端并发服务器的实现，采用 C 语言开发，以 epoll + 动态线程池的方式受理客户端的请求。现在的生态环境已经非常成熟，各种第三方和开源的组件都提供了完美的解决方案，不再需要开发人员自己造轮子了。

  • 首先是头文件中的定义。
#define	SUCCESS		0
#define	FAILURE		1

#define	UINT		unsigned int
#define	UCHAR		unsigned char
#define	ULONG		unsigned long
#define	USHORT		unsigned short
#define	ULONGLONG	unsigned long long

#define	LOW_WEIGHT	0.2		// 低于该值销毁部分线程
#define	TOP_WEIGHT	0.6		// 高于该值创建部分线程

#define	DELAY_TIME	50		// 创建线程延时
#define	SLEEP_TIME	10		// 管理线程池线程休眠延时
#define	PACKET_SIZE	1024	// 报文大小

#define	LISTENQ		20		// 监听队列
#define	EVENT_MAX	256		// epoll_wait返回活动套接字数组大小
#define	CLIENT_MAX	10000	// 并发最大值
#define	SERVER_PORT	12345	// 主套接字监听端口

#define	IDLE_STATUS	0		// 线程空闲
#define	BUSY_STATUS	1		// 线程忙碌
  • 接下来是线程池和线程属性定义。
/* 工作线程属性 */
typedef struct tagWorkThread
{
    pthread_t m_iWorkThreadID;
    UINT m_uiStatus;
    pthread_cond_t m_condWork;
    pthread_mutex_t m_mutexWork;
    int m_iClientSocket;
}WORKTHREAD_S;

#define	NEW_LEVEL	10		// 每次新创建线程数
#define	MIN_LEVEL	10		// 线程池内线程数最小值
#define	MAX_LEVEL	100		// 线程池内线程数最大值

/* 线程池属性 */
typedef struct tagThreadPool
{
    int m_iEpoll;
    UINT m_uiMinimum;
    UINT m_uiMaximal;
    UINT m_uiCurrent;
    pthread_t m_iManegeThreadID;
    pthread_mutex_t m_mutexPool;
    pthread_mutex_t m_mutexManage;
    WORKTHREAD_S *m_pstWork;
}THREADPOOL_S;

/* 全局变量用于保存析构数据地址 */
typedef struct tagGeneralParameter
{
    int *m_piSocket;
    THREADPOOL_S *m_pstThreadPool;
}GENERALPARAMETER_S;
  • 然后是一些必要的初始化
/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：变更文件描述符的内核限制			                */
/* 参数：无						                        */
/********************************************************/
int InitLimit()
{
    struct rlimit stLimit;

    stLimit.rlim_max = stLimit.rlim_cur = CLIENT_MAX;
    if( setrlimit(RLIMIT_NOFILE,&stLimit) == -1 ) {
        fprintf(stderr,"Failed to setrlimit,%s!\n",strerror(errno));
        return FAILURE;
    }

    return SUCCESS;
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：初始化epoll相关资源				                */
/* 参数：无						                        */
/********************************************************/
int InitEpoll()
{
    int iReturn = -1;

    iReturn = epoll_create(CLIENT_MAX);
    if( iReturn < 0 ) {
        fprintf(stderr,"Failed to epoll_create,%s!\n",strerror(errno));
        return iReturn;
    }

    return iReturn;
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：初始化主监听套接字				                    */
/* 参数：piSocket主监听套接字；pstServer服务器信息	        */
/* iEpoll套接字队列					                    */
/********************************************************/
int InitSocket(int *piSocket,struct sockaddr_in *pstServer,int iEpoll)
{
    int iReturn = 0;
    struct epoll_event stEpoll;

    *piSocket = socket(AF_INET,SOCK_STREAM,0);
    if( *piSocket < 0 ) {
        fprintf(stderr,"Failed to socket,%s!\n",strerror(errno));
        return FAILURE;
    }

    memset(pstServer,'\0',sizeof(struct sockaddr_in));
    pstServer->sin_family = AF_INET;
    pstServer->sin_addr.s_addr = htonl(INADDR_ANY);
    pstServer->sin_port = htons(SERVER_PORT);

    iReturn = bind(*piSocket,(struct sockaddr *)pstServer,sizeof(struct sockaddr_in));
    if( iReturn < 0 ) {
        fprintf(stderr,"Failed to bind,%s!\n",strerror(errno));
        return FAILURE;
    }

    iReturn = listen(*piSocket,LISTENQ);
    if( iReturn < 0 ) {
        fprintf(stderr,"Failed to listen,%s!\n",strerror(errno));
        return FAILURE;
    }

    /* 设置套接字为非阻塞模式 */
    if( fcntl(*piSocket,F_SETFL,fcntl(*piSocket,F_GETFD,0) | O_NONBLOCK) == -1 ) {
        fprintf(stderr,"Failed to fcntl,%s!\n",strerror(errno));
        return FAILURE;
    }

    stEpoll.data.fd = *piSocket;
    stEpoll.events = EPOLLIN | EPOLLET;
    if( epoll_ctl(iEpoll,EPOLL_CTL_ADD,*piSocket,&stEpoll) < 0 ) {
        fprintf(stderr,"Failed to epoll_ctl,%s\n",strerror(errno));
        return FAILURE;
    }

    return SUCCESS;
}
  • 再有一些必要的通用调用
/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：信号处理函数					                    */
/* 参数：信号值						                    */
/********************************************************/
void SignalQuit(int iSignal)
{
    ReleaseResource();
    exit(SUCCESS);
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：析构函数					                        */
/* 参数：无						                        */
/********************************************************/
void ReleaseResource()
{
    int iCount = 0;
    int iCurrent = 0;

    pthread_mutex_lock(&g_stGeneralParameter.m_pstThreadPool->m_mutexPool);
    iCurrent = g_stGeneralParameter.m_pstThreadPool->m_uiCurrent;
    pthread_mutex_unlock(&g_stGeneralParameter.m_pstThreadPool->m_mutexPool);

    for( iCount = 0 ; iCount < iCurrent ; iCount ++ ) {
        pthread_cancel((g_stGeneralParameter.m_pstThreadPool->m_pstWork + iCount)->m_iWorkThreadID);
        pthread_cond_destroy(&(g_stGeneralParameter.m_pstThreadPool->m_pstWork + iCount)->m_condWork);
        pthread_mutex_destroy(&(g_stGeneralParameter.m_pstThreadPool->m_pstWork + iCount)->m_mutexWork);
    }


    pthread_cancel(g_stGeneralParameter.m_pstThreadPool->m_iManegeThreadID);
    pthread_mutex_destroy(&g_stGeneralParameter.m_pstThreadPool->m_mutexPool);
    pthread_mutex_destroy(&g_stGeneralParameter.m_pstThreadPool->m_mutexManage);

    //if( g_stGeneralParameter.m_pstThreadPool->m_pstWork ) free(g_stGeneralParameter.m_pstThreadPool->m_pstWork);

    if( *g_stGeneralParameter.m_piSocket ) {
        close(*g_stGeneralParameter.m_piSocket);
    }
}
  • 再然后是线程池的构造和析构
/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：创建线程					                        */
/* 参数：pstThreadPool线程池信息			                */
/********************************************************/
int CreateThreadGroup(THREADPOOL_S *pstThreadPool)
{
    int iCount = 0;
    int iNumber = 0;
    int iCurrent = 0;
    pthread_attr_t attrThread;

    /* 创建和销毁二个线程的互斥锁，避免创建销毁同时发生 */
    pthread_mutex_lock(&pstThreadPool->m_mutexManage);

    /* 读取线程池中线程总数 */
    pthread_mutex_lock(&pstThreadPool->m_mutexPool);
    iCurrent = pstThreadPool->m_uiCurrent;
    pthread_mutex_unlock(&pstThreadPool->m_mutexPool);

    if( !iCurrent ) {
        iNumber = MIN_LEVEL;
    }
    else if( iCurrent + NEW_LEVEL <= MAX_LEVEL ) {
        iNumber = NEW_LEVEL;
    }
    else {
        return SUCCESS;
    }

    /* 创建的新线程设置为分离态，由系统回收其资源 */
    if( pthread_attr_init(&attrThread) ) {
        fprintf(stderr,"Failed to pthread_attr_init,%s!\n",strerror(errno));
        return FAILURE;
    }
    if( pthread_attr_setdetachstate(&attrThread,PTHREAD_CREATE_DETACHED) ) {
        fprintf(stderr,"Failed to pthread_attr_setdetachstate,%s!\n",strerror(errno));
        return FAILURE;
    }
    for( iCount = 0 ; iCount < iNumber ; iCount ++ ) {
        pthread_cond_init(&(pstThreadPool->m_pstWork + iCurrent + iCount)->m_condWork,NULL);
        pthread_mutex_init(&(pstThreadPool->m_pstWork + iCurrent + iCount)->m_mutexWork,NULL);
        if( pthread_create(&(pstThreadPool->m_pstWork + iCurrent + iCount)->m_iWorkThreadID,&attrThread,(void *)WorkThreads,(void *)pstThreadPool) ) {
            fprintf(stderr,"Failed to pthread_create,%s!\n",strerror(errno));
            return FAILURE;
        }
    }

    /* 创建完成后再更改线程池线程总数 */
    pthread_mutex_lock(&pstThreadPool->m_mutexPool);
    pstThreadPool->m_uiCurrent += iNumber;
    pthread_mutex_unlock(&pstThreadPool->m_mutexPool);

    pthread_attr_destroy(&attrThread);

    /* 延时是为了避免线程信号在线程创建前到达，避免系统未处理用户数据而在epoll_wait上挂起，延时值为经验值 */
    usleep(DELAY_TIME);

    pthread_mutex_unlock(&pstThreadPool->m_mutexManage);

    return SUCCESS;
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：销毁线程					                        */
/* 参数：pstThreadPool线程池信息			                */
/********************************************************/
int DeleteThreadGroup(THREADPOOL_S *pstThreadPool)
{
    int iCount = 0;
    int iCurrent = 0;

    /* 创建和销毁二个线程的互斥锁，避免创建销毁同时发生 */
    pthread_mutex_lock(&pstThreadPool->m_mutexManage);

    /* 读取线程池中线程总数 */
    pthread_mutex_lock(&pstThreadPool->m_mutexPool);
    iCurrent = pstThreadPool->m_uiCurrent - 1;
    if( iCurrent > MIN_LEVEL ) {
        iCount = (pstThreadPool->m_uiCurrent -= NEW_LEVEL);
    }
    else {
        pthread_mutex_unlock(&pstThreadPool->m_mutexPool);
        return SUCCESS;
    }
    pthread_mutex_unlock(&pstThreadPool->m_mutexPool);

    while( iCurrent >= iCount ) {
        pthread_cancel((pstThreadPool->m_pstWork + iCurrent)->m_iWorkThreadID);
        pthread_cond_destroy(&(pstThreadPool->m_pstWork + iCurrent)->m_condWork);
        pthread_mutex_destroy(&(pstThreadPool->m_pstWork + iCurrent)->m_mutexWork);
        iCurrent --;
    }

    pthread_mutex_unlock(&pstThreadPool->m_mutexManage);

    return SUCCESS;
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：工作线程					                        */
/* 参数：pstThreadPool线程池信息			                */
/********************************************************/
void *WorkThreads(THREADPOOL_S *pstThreadPool)
{
    int iArray = 0;
    struct epoll_event stEpoll;

    iArray = GetWorkThreadArray(pstThreadPool,pthread_self());
    if( iArray < 0 ) pthread_exit(NULL);

    while( 1 ) {
        pthread_mutex_lock(&(pstThreadPool->m_pstWork + iArray)->m_mutexWork);
        while( (pstThreadPool->m_pstWork + iArray)->m_uiStatus == IDLE_STATUS ) {
            pthread_cond_wait(&(pstThreadPool->m_pstWork + iArray)->m_condWork,&(pstThreadPool->m_pstWork + iArray)->m_mutexWork);
        }
        pthread_mutex_unlock(&(pstThreadPool->m_pstWork + iArray)->m_mutexWork);

        /* 用户数据处理函数，客户端终止EPOLLIN行为数据读取返回为0 */
        if( !PrivateFunction(iArray,(pstThreadPool->m_pstWork + iArray)->m_iClientSocket) ) {
            stEpoll.data.fd = (pstThreadPool->m_pstWork + iArray)->m_iClientSocket;
            epoll_ctl(pstThreadPool->m_iEpoll,EPOLL_CTL_DEL,(pstThreadPool->m_pstWork + iArray)->m_iClientSocket,&stEpoll);
            close((pstThreadPool->m_pstWork + iArray)->m_iClientSocket);
        }

        pthread_mutex_lock(&(pstThreadPool->m_pstWork + iArray)->m_mutexWork);
        (pstThreadPool->m_pstWork + iArray)->m_uiStatus = IDLE_STATUS;
        pthread_mutex_unlock(&(pstThreadPool->m_pstWork + iArray)->m_mutexWork);
    }

    pthread_exit(NULL);
}
  • 接下来是初始化线程池管理线程和相关操作
/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：初始化线程池管理线程				                */
/* 参数：pstThreadPool线程池信息			                */
/********************************************************/
int InitManageThread(THREADPOOL_S *pstThreadPool)
{
    if( pthread_create(&pstThreadPool->m_iManegeThreadID,NULL,(void *)ManageThread,(void *)pstThreadPool) ) {
        fprintf(stderr,"Failed to pthread_create,%s!\n",strerror(errno));
        return FAILURE;
    }

    return SUCCESS;
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：线程池管理线程					                */
/* 参数：pstThreadPool线程池信息			                */
/********************************************************/
void *ManageThread(THREADPOOL_S *pstThreadPool)
{
    int iCount = 0;
    int iNumber = 0;
    float fPercent = 0.0;

    while( 1 ) {
        /* 管理线程轮询休眠时间经验值 */
        sleep(SLEEP_TIME);
        for( iCount = 0 ; iCount < pstThreadPool->m_uiCurrent ; iCount ++ ) {
            if( (pstThreadPool->m_pstWork + iCount)->m_uiStatus == BUSY_STATUS ) iNumber ++;
        }
        /* 线程忙碌百分比 */
        fPercent = (float)(iNumber / pstThreadPool->m_uiCurrent);
        if( fPercent < LOW_WEIGHT ) {
            if( DeleteThreadGroup(pstThreadPool) ) {
                fprintf(stderr,"Failed to delete thread group!\n");
                continue;
            }
        }
        else if( fPercent > TOP_WEIGHT ) {
            if( CreateThreadGroup(pstThreadPool) ) {
                fprintf(stderr,"Failed to create thread group!\n");
                continue;
            }
        }
    }

    pthread_exit(NULL);
}

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：获取线程数据中的下标				                */
/* 参数：pstThreadPool线程池信息；iWorkThreadID线程ID	    */
/********************************************************/
int GetWorkThreadArray(THREADPOOL_S *pstThreadPool,pthread_t iWorkThreadID)
{
    int iCount = 0;

    for( iCount = 0 ; iCount < pstThreadPool->m_uiMaximal ; iCount ++ ) {
        if( (pstThreadPool->m_pstWork + iCount)->m_iWorkThreadID == iWorkThreadID ) return iCount;
    }

    return -1;
}
  • 最后是主程入口
GENERALPARAMETER_S g_stGeneralParameter = { NULL };

/********************************************************/
/* 日期：2009年10月15日					                */
/* 函数：主函数，程序入口。				                    */
/* 参数：h打印帮助信息；v现实版本信息			            */
/********************************************************/
int main(int argc,char *argv[])
{
    pid_t iPid;
    int iEpoll = 0;
    int iWorks = 0;
    int iCount = 0;
    int iNumber = 0;
    int iSocket = 0;
    int iCurrent = 0;
    int iNewSocket = 0;
    int iOptionIndex = 0;
    int iOptionReturn = 0;
    socklen_t iClientSize = 0;
    THREADPOOL_S stThreadPool;
    struct sockaddr_in stServer;
    struct sockaddr_in stClient;
    struct epoll_event stEpoll;
    struct epoll_event stEvent[EVENT_MAX];

    struct option stOptions[] = {
            {"help",0,0,'h'},
            {"version",0,0,'v'},
            {0,0,0,0},
    };

    while( 1 ) {
        iOptionReturn = getopt_long(argc,argv,"hv",stOptions,&iOptionIndex);
        if( iOptionReturn < 0 ) {
            break;
        }
        switch(iOptionReturn) {
            case 'h':	PrintHelp();
                return SUCCESS;
            case 'v':	printf("Copyright (C) 2008. \n");
                printf("Version 1.0.0 Build on %s %s.\n",__DATE__,__TIME__);
                return SUCCESS;
            default:	return SUCCESS;
        }
    }

    /* 创建子进程并让子进程成为守护进程 */
    iPid = fork();
    if( iPid < 0 ) {
        fprintf(stderr,"Failed to fork,%s!\n",strerror(errno));
        return FAILURE;
    }
    else if( iPid > 0 ) {
        return SUCCESS;
    }

    if( setsid() < 0 ) {
        fprintf(stderr,"Failed to setsid,%s!\n",strerror(errno));
        return FAILURE;
    }
    if( chdir("/") < 0 ) {
        fprintf(stderr,"Failed to chdir,%s!\n",strerror(errno));
        return FAILURE;
    }
    umask(0);

    /* 注册析构函数和信号处理函数 */
    atexit(ReleaseResource);
    signal(SIGINT,SignalQuit);
    signal(SIGSEGV,SignalQuit);
    signal(SIGTERM,SignalQuit);

    /* 更改内核文件描述符限制 */
    printf("Setting the max value of file handle in kernel ...\n");
    if( InitLimit() ) {
        fprintf(stderr,"Failed to initialize limit,%s!\n",strerror(errno));
        return FAILURE;
    }

    /* 初始化epoll相关调用 */
    printf("Initializing epoll handle....\n");
    iEpoll = InitEpoll();
    if( iEpoll < 0 ) {
        fprintf(stderr,"Failed to initialize poll,%s!\n",strerror(errno));
        return FAILURE;
    }

    /* 初始化主套接字 */
    printf("Initializing socket...\n");
    if( InitSocket(&iSocket,&stServer,iEpoll) ) {
        fprintf(stderr,"Failed to initialize socket,%s!\n",strerror(errno));
        return FAILURE;
    }

    /* 创建线程池 */
    printf("Creating thread pool...\n");
    if( InitThreadPool(&stThreadPool,iEpoll) ) {
        fprintf(stderr,"Failed to initialize thread pool!\n");
        return FAILURE;
    }

    /* 创建线程池管理线程 */
    printf("Creating a manage thread to control thread's total...\n");
    if( InitManageThread(&stThreadPool) ) {
        fprintf(stderr,"Failed to create ControlThread,%s!\n",strerror(errno));
        return FAILURE;
    }

    /* 将析构数据赋予全局变量并在析构函数中调用 */
    g_stGeneralParameter.m_piSocket = &iSocket;
    g_stGeneralParameter.m_pstThreadPool = &stThreadPool;

    /* 关闭标准输入输出和错误 */
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);

    /* 主进程进入监听状态 */
    iClientSize = (socklen_t)sizeof(struct sockaddr_in);
    while( 1 ) {
        memset(&stEvent,'\0',sizeof(struct epoll_event) * EVENT_MAX);
        iNumber = epoll_wait(iEpoll,stEvent,EVENT_MAX,-1);
        for( iWorks = 0 ; iWorks < iNumber ; iWorks ++ ) {
            /* 新接入套接字 */
            if( stEvent[iWorks].data.fd == iSocket ) {
                while( (iNewSocket = accept(iSocket,(struct sockaddr *)&stClient,&iClientSize)) > 0 ) {
                    if( fcntl(iNewSocket,F_SETFL,fcntl(iNewSocket,F_GETFD,0) | O_NONBLOCK) == -1 ) {
                        fprintf(stderr,"Failed to fcntl,%s!\n",strerror(errno));
                        continue;
                    }
                    stEpoll.events = EPOLLIN | EPOLLET;
                    stEpoll.data.fd = iNewSocket;
                    if( epoll_ctl(iEpoll,EPOLL_CTL_ADD,iNewSocket,&stEpoll) < 0 ) {
                        fprintf(stderr,"Failed to epoll_ctl,%s\n",strerror(errno));
                        continue;
                    }
                }
            }
                /* 已有套接字 */
            else {
                iCount = 0;
                /* 线程池中线程总数 */
                pthread_mutex_lock(&stThreadPool.m_mutexPool);
                iCurrent = stThreadPool.m_uiCurrent;
                pthread_mutex_unlock(&stThreadPool.m_mutexPool);
                /* 最大线程数 */
                if( iCurrent == MAX_LEVEL ) {
                    while( iCount < MAX_LEVEL ) {
                        pthread_mutex_lock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                        if( !(stThreadPool.m_pstWork + iCount)->m_uiStatus ) {
                            (stThreadPool.m_pstWork + iCount)->m_uiStatus = BUSY_STATUS;
                            (stThreadPool.m_pstWork + iCount)->m_iClientSocket = stEvent[iWorks].data.fd;
                            pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                            pthread_cond_signal(&(stThreadPool.m_pstWork + iCount)->m_condWork);
                            break;
                        }
                        else {
                            pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                        }
                        if( ++ iCount == MAX_LEVEL ) iCount = 0;
                    }
                }
                    /* 非最大线程数 */
                else {
                    for( ; iCount < iCurrent ; iCount ++ ) {
                        pthread_mutex_lock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                        if( (stThreadPool.m_pstWork + iCount)->m_uiStatus == IDLE_STATUS ) {
                            (stThreadPool.m_pstWork + iCount)->m_uiStatus = BUSY_STATUS;
                            (stThreadPool.m_pstWork + iCount)->m_iClientSocket = stEvent[iWorks].data.fd;
                            pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                            pthread_cond_signal(&(stThreadPool.m_pstWork + iCount)->m_condWork);
                            break;
                        }
                        else {
                            pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                        }
                    }
                    /* 所有线程忙碌并创建新线程 */
                    if( iCount == iCurrent ) {
                        if( !CreateThreadGroup(&stThreadPool) ) {
                            pthread_mutex_lock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                            if( !(stThreadPool.m_pstWork + iCount)->m_uiStatus ) {
                                (stThreadPool.m_pstWork + iCount)->m_uiStatus = BUSY_STATUS;
                                (stThreadPool.m_pstWork + iCount)->m_iClientSocket = stEvent[iWorks].data.fd;
                                pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                                pthread_cond_signal(&(stThreadPool.m_pstWork + iCount)->m_condWork);
                            }
                            else {
                                pthread_mutex_unlock(&(stThreadPool.m_pstWork + iCount)->m_mutexWork);
                            }
                        }
                    }
                }
            }
        }
    }

    return SUCCESS;
}

        代码中关键位置都附上了注释，熟悉 epoll 和底层线程实现的话看着应该不复杂，供大家参考。

厉力文武
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C 语言网络编程 — 高并发 TCP 网络服务器
烟云的计算
03-09 1210
可见，I/O 多路复用模型大大增加了每个进程可以管理的 Socket 数量，直到操作系统 fd 最大数量限制为止，通常可以设置百万级别，即：单机单进程支持百万连接，epoll 是解决 C10K 的利器，很多开源软件用到了它。四次挥手是一个冗长的过程，由于网络环境的复杂性与 TCP 连接的可靠性相违背，所以在某些特殊的场景中会出现相应的问题。所以，实际上，close() 并不会马上断开 Socket Connection，在高性能网络服务器中，需要非常关注 TCP 连接的状态情况。
Linux + C + Epoll实现高并发服务器(线程池 + 数据库连接池)
09-27
在Linux 系统下面用C 语言实现的高并发服务器的代码，具体用到了Epoll，线程池，数据库连接池。 具体可以看下连接http://blog.csdn.net/wuyuxing24/article/details/48758927
C语言 多线程实现TCP并发服务器
ma_de_hao_mei_le的博客
03-27 4942
友链 重点难点就是内存的管理，我们在全局作用域初始化了一个子线程参数数组（有点线程池的味道了），以避免子线程回调函数的参数指向的内存被回收 子线程数组的大小就是我们的并发服务器能够支持的最高并发量，如果超过了，就让客户端进行等待，直到线程数组出现空闲的子线程 其实我们一直都在创建子线程，但是通过子线程回调函数的参数数组将子线程的数量限制在了指定的范围内 gcc 1.c -o 1 -lpthread // 、、使用内存映射可以拷贝文件 /* 对原始文件进行内存映射 创建一个新文件 把新文件的数据拷贝映射到内存
使用Go语言实现高效的并发编程
Code Metaverse
12-15 1382
Go语言支持并发编程。你可以通过创建多个并发单元（称为goroutines）来实现多线程编程。每个goroutine都是一个独立的执行单元，可以并行执行代码。这样，两个函数就会同时执行，可以大大提高程序的效率。Go语言提供了一些内置的通信机制（例如信道）来协调多个goroutine之间的交互。这个特性可以帮助我们编写高效的并发程序，可以充分利用多核处理器的优势，提高程序的性能。
C语言实现http服务器（Linux）
baixingyubxy的博客
07-24 8419
基于linux操作系统，C语言实现轻量级http服务器
【C语言】Linux实现高并发处理的过程
数字人生
01-06 1475
一、实现高并发的几种策略 C语言本身并没有内建的多线程支持（新版C语言支持，但用得不多），但是在多数操作系统中，可以使用库来实现多线程编程。例如，在POSIX兼容系统上，可以使用 pthreads 库来创建和管理线程。然而，传统的多线程存在着资源限制，比如每个线程都需要独立的堆栈空间，上下文切换开销大，线程数量多时还会导致竞争情况加剧。 为了兼顾高并发和高性能，可以采取以下几种策略： 1. 线程池(Thread Pools)：创建一个线程池来管理一定数量的线程，避免了频繁创建和销毁线程的开销，可以复用线程
并发王者erlang语言编程初步
微小冷的学习笔记
03-17 1585
Erlang是一种通用的面向并发的编程语言，由爱立信所辖的CS-Lab开发，目的是创造一种可以应对大规模并发活动的编程语言和运行环境。
shell实现多并发控制
qq_45443879的博客
06-13 5941
Shell实现并发执行任务
C语言基本并发操作简介
旎彩的博客
03-25 3576
C语言基本并发操作简介引言实验环境利用fork函数创建进程创建实例进程之间的竞争竞争实例创建线程等待线程注意事项线程实例线程共享数据共享数据实例总结 引言 在处理一些数据集比较繁杂且解题思路比较单一的问题时，可以通过同一个算法计算多次循环操作解决，但当对效率要求比较高的时候，如果电脑的配置比较好，通常倾向于采用并发编程，其中，线程之间由于切换比较复杂，上下文切换时间较长，并且进程间数据共享比较麻烦，这里我们通常倾向于利用多线程的方法来解决问题。这里我们简要介绍一下多进程、线程思想的一些基本操作。 实验环境
Go语言并发编程——原子操作
m0_62969222的博客
09-30 1878
而互斥锁实现的操作，当前执行Goroutine是会被其它Goroutine抢占的，但是其它的Goroutine在未获取锁的情况并不能顺利执行，从而保证了并发的安全性。同样的，在未使用原子写时，可能写到一半的数据被读到，所以要保证并发的安全性，要同时保证读和写的原子性，或者使用互斥锁保证读和写之间互斥，写和写之间也互斥。在非原子读时，可能会造成：读到一半Goroutine被中断，当Goroutine再次被调度时，数据已被修改，那么最终读出来的就是一个奇怪的值。原子操作能够使用的场景很少，是有很大局限性的。
实现一个FTP服务系统 c语言
qq_24624539的博客
12-13 2079
实现一个FTP服务系统 一、实验目的 通过该实验，掌握Linux环境下的多线程/进程编程技术、文件操作、用户权限管理、进程间通信技术 实验要求 基于客户/服务器交互模式，采用TCP/IP通信协议，实现一个支持远程文件传输的客户/服务器软件，支持文件的上传和下载。其中客户端软件命名为myftp，服务器软件命名为ftpserver，具体功能需求如下： 服务器 启动方式。执行ftpserver [IP地址] port启动FTP服务。其中IP地址为可选项。若不提供服务器IP地址，FTP服务将自动绑定到本地网
Go语言并发打印（借助通道实现）
01-20
 下面介绍一个并发打印的例子，将goroutine和channel放在一起展示它们的用法； package main import “fmt” func printer(c chan int) {  //开始无限循环等待数据  for {  //从channel 中获取一个数据  
Go语言并发技术详解
12-31
有人把Go比作21世纪的C语言，第一是因为Go语言设计简单，第二，21世纪最重要的就是并行程序设计，而Go从语言层面就支持了并行。 goroutine goroutine是Go并行设计的核心。goroutine说到底其实就是线程，但是它比线程...
Python网络编程实现DHCP服务器
02-11
设计语言：Python、C/C++。 3. 原理：根据 DHCP 工作过程，即 DHCP 正常工作的所需的几种 DHCP报文，在收到的客户的 DHCP 报文之后，服务器正确构造相应的 DHCP 响应报文并发送给 DHCP 客户。 4. 技术难点：分析...
在Go中构建并发TCP服务器
01-03
开发一个并发TCP服务器，该服务器仅使用大约65行GO代码生成随机数。 TCP和UDP服务器随处可见，通过TCP/IP网络为网络客户端提供服务。在本文中，我将在GO编程语言，返回随机数。对于来自TCP客户端的每个传入连接，...
比大小（打擂台）（C语言）
m0_67184754的博客
05-14 211
【代码】比大小（打擂台）（C语言）
c语言：递归与迭代
qq_58761784的博客
05-14 1088
它却没有得出结果，这是为什么呢，因为，函数在内部多次调用了自己，产生了大量的重复计算，导致计算量巨大，代码执行效率非常低，让计算机也无法快速得出结果，这个例子告诉我们，递归是有使用条件的 ，如果要设计一个需要重复计算的程序，不能无脑使用递归，而是首先要思考递归能不能用，是否能让代码简洁的同时，更加高效，那么此类例子我们如何解决呢？可以看到，很快就得到了结果，但是答案是错误的，因为要求的数太大，一个字节无法表示，但是我们可以很直观的看见两者的差别，在这这样一个例子中，使用迭代会优于使用递归。
手撕C语言题典——链表的中间节点
Antigonos的博客
05-14 400
链表的中间节点同样也是力扣上一道简单题，适合刚学过单链表的我们更好的理解链表相关知识~
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
最新发布
05-14 1100
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
Go语言实现并发编程的流程
04-19
首先，在Go语言中，实现并发编程需要使用goroutine和channel。goroutine是一种轻量级的线程，可以并发运行在同一个进程中。使用go关键字启动一个goroutine，例如：go func() {...}。channel是多个goroutine之间进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

厉力文武

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

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

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

打赏作者

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

抵扣说明：

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

余额充值