4.20-4.22多进程/多线程实现并发服务器

l_ethan

已于 2022-07-25 14:25:23 修改

阅读量473

点赞数

分类专栏： Linux环境编程文章标签：服务器

于 2022-06-24 10:11:43 首次发布

本文链接：https://blog.csdn.net/l_ethan/article/details/125440373

版权

Linux环境编程专栏收录该内容

62 篇文章 1 订阅

订阅专栏

多进程server:

#include<stdio.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<signal.h>
#include<wait.h>
#include<errno.h>

void recyleChild(int arg){
    while(1){
        int ret=waitpid(-1,NULL,WNOHANG);
        if(ret==-1){
            //所有子进程都回收了
            break;
        }else if(ret==0){
            //还有子进程活着
            break;
        }else if(ret>0){
            //被回收了
            printf("子进程 %d 被回收了\n",ret);
        }
    }
}
int main(){
    struct sigaction act;
    act.sa_flags=0;
    sigemptyset(&act.sa_mask);
    act.sa_handler=recyleChild;
    //注册信号捕捉
    sigaction(SIGCHLD,&act,NULL);
    
    //创建socket
    int lfd=socket(PF_INET,SOCK_STREAM,0);//PF_INET表示ipv4 SOCK_STREAM表示流式协议 0表示使用默认 这里是tcp
    if(lfd==-1){
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in saddr;
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(9999);
    saddr.sin_addr.s_addr=INADDR_ANY;

    //设置端口复用
    int optval=1;
    setsockopt(lfd,SOL_SOCKET,SO_REUSEPORT,&optval,sizeof(optval));
    
    //绑定
    int ret=bind(lfd,(struct sockaddr *)&saddr,sizeof (saddr));
    if(ret==-1){
        perror("bind");
        exit(-1);
    }

    //监听
    ret = listen(lfd,128);//128表示未连接的和已经连接的和的最大值
    if(ret==-1){
        perror("listen");
        exit(-1);
    }

    while(1){
        struct sockaddr_in cliaddr;
        int len=sizeof(cliaddr);
        //接受连接
        int cfd = accept(lfd,(struct sockaddr*)&cliaddr,&len);
        if(cfd==-1){
            if(errno==EINTR)//软中断产生的错误忽略避免子进程结束父进程也随之结束
            {
                continue;
            }
            perror("accept");
            exit(-1);
        }

        //每一个连接进来，创建一个子进程跟客户端通信
        pid_t pid = fork();
        if(pid==0){
            //子进程
            //获取客户端的信息
            char clilp[16];
            inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,clilp,sizeof(clilp));
            unsigned short cliPort=ntohs(cliaddr.sin_port);
            printf("client ip is : %s,port is %d\n",clilp,cliPort);

            //接收客户端发来的数据
            char recvBuf[1024];
            while(1){
                int len=read(cfd,&recvBuf,sizeof(recvBuf));
                if(len==-1){
                    perror("read");
                    exit(-1);
                }
                else if(len>0){
                    printf("recv client : %s\n",recvBuf);
                }else if(len==0){
                    printf("client closed...\n");
                    break;
                }
                write(cfd,recvBuf,strlen(recvBuf)+1);//这里+1是为了把'/0'写入避免出错乱码
            }
            close(cfd);
            exit(0);//退出当前子进程
        }
    }
    close(lfd);
    return 0;
}

多线程server:

#include<stdio.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
struct sockInfo{
    int fd;//通信的文件描述符
    struct sockaddr_in addr;
    pthread_t tid;//线程号
};
struct sockInfo sockinfos[128];
void * working(void *arg){
    //子线程和客户端通信 cfd客户端的信息 线程号
    //获取客户端的信息
    struct sockInfo * pinfo=(struct sockInfo *)arg;

    char clilp[16];
    inet_ntop(AF_INET,&pinfo->addr.sin_addr.s_addr,clilp,sizeof(clilp));
    unsigned short cliPort = ntohs(pinfo->addr.sin_port);
    printf("client ip is : %s,port is %d\n",clilp,cliPort);

    //接受客户端发送来的数据
    char recvBuf[1024];
    while(1){
        int len = read(pinfo->fd,&recvBuf,sizeof(recvBuf));

        if(len==-1){
            perror("read");
            exit(-1);
        }else if(len>0){
            printf("recv client : %s\n",recvBuf);
        }else if(len==0){
            printf("client closed\n");
            break;
        }
        write(pinfo->fd,recvBuf,strlen(recvBuf)+1);
    }
    close(pinfo->fd);
    return NULL;
}
int main(){
    int lfd = socket(PF_INET,SOCK_STREAM,0);
    if(lfd==-1){
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in saddr;
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(9999);
    saddr.sin_addr.s_addr=INADDR_ANY;

    //绑定
    int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1){
        perror("bind");
        exit(-1);
    }
    
    //监听
    ret = listen(lfd,128);
    if(ret == -1){
        perror("listen");
        exit(-1);
    }

    //初始化数据
    int max = sizeof(sockinfos)/sizeof(sockinfos[0]);
    for(int i=0;i<max;i++){
        bzero(&sockinfos[i],sizeof(sockinfos[i]));
        sockinfos[i].fd=-1;
        sockinfos[i].tid=-1;
    }

    //循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信
    while(1)
    {
        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        //接受连接
        int cfd = accept(lfd,(struct sockaddr*)&cliaddr,&len);

        struct sockInfo * pinfo;
        for(int i=0;i<max;i++){
            //从这个数组中找到一个可以用sockinfo元素
            if(sockinfos[i].fd==-1){
                pinfo=&sockinfos[i];
                break;
            }
            if(i==max-1){
                sleep(1);
                i--;
            }
        }
        pinfo->fd=cfd;
        memcpy(&pinfo->addr,&cliaddr,len);
        //创建子线程
        pthread_create(&pinfo->tid,NULL,working,pinfo);

        pthread_detach(pinfo->tid);/*如果一个可结合线程结束运行但没有被join，则它的状态类似于进程中的Zombie Process，即还有一部分资源没有被回收，所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源。由于调用pthread_join后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此。例如，在Web服务器中当主线程为每个新来的连接请求创建一个子线程进行处理的时候，主线程并不希望因为调用pthread _join而阻塞（因为还要继续处理之后到来的连接请求)，这时可以在子线程中加入代码pthread detach(pthread_self())或者父线程调用pthread detach(thread_id)(非阻塞,可立即返回)这将该子线程的状态设置为分离的(detached)，如此一来，该线程运行结束后会自动释放所有资源。*/

    }

    close(lfd);    
    return 0;
}

client:

//TCP通信的客户端
#include<stdio.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>

int main(){
    //1.创建套接字
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd==-1){
        perror("socket");
        exit(-1);
    }

    //2.连接服务器
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    inet_pton(AF_INET,"192.168.108.128",&serveraddr.sin_addr);
    serveraddr.sin_port=htons(9999);
    int ret = connect(fd,(struct sockaddr*)&serveraddr,sizeof(serveraddr));

    if(ret==-1){
        perror("connect");
        exit(-1);
    }

    //3.通信
    char recvBuf[1024];
    int i=0;
    while(1){
        sprintf(recvBuf,"data : %d\n",i++);

        //给服务器端发送数据
        write(fd,recvBuf,strlen(recvBuf)+1);

        int len=read(fd,recvBuf,sizeof(recvBuf));
        if(len==-1){
            perror("read");
            exit(-1);
        }else if(len>0){
            printf("recv server : %s\n",recvBuf);
        }else if(len==0){
            //表示服务器断开连接
            printf("server closed...");
            break;
        }
        sleep(1);
    }
    
    close(fd);
    return 0;
}