Multi-process and multi-thread implementation of concurrent server

Multiple processes

Server code:

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

using namespace std;

void recycle(int arg)
{
    while(1)
    {
        int ret=waitpid(-1,NULL,WNOHANG);
        if(ret==-1) break;
        else if(ret==0) break;
        else if (ret >0)
        {
            cout << "child process" << ret << "recycled" << endl;
        }

    }
}


int main()
{
    //create socket
    int sfd=socket(AF_INET,SOCK_STREAM,0);
    if(sfd==-1)
    {
        perror("sock");
        exit(-1);
    }

    // signal capture
    struct sigaction act;
    act.sa_flags=0;
    sigemptyset( &act.sa_mask);
    act.sa_handler = recycle;
    int t=sigaction(SIGCHLD, &act,NULL);
    if(t==-1)
    {
        perror("sigaction");
        exit(-1);
    }
 
    //bind
    struct sockaddr_in saddr;
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(4002);
    saddr.sin_addr.s_addr=INADDR_ANY;
    int ret=bind(sfd,(struct sockaddr *) & amp;saddr,sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }

    //monitor
    ret=listen(sfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    //accept
    while(1)
    {
        struct sockaddr_in cliaddr;
        socklen_t len=sizeof(cliaddr. sin_addr. s_addr);
        int cfd=accept(sfd,(struct sockaddr *) & amp;cliaddr, & amp;len);
        if(cfd==-1)
        {
            if(errno==EINTR) continue;
            perror("accept");
            exit(-1);
        }
        pid_t pid=fork();

        if(pid == 0)
        {
            //child process
             char buf[1024]={0};
             while(1)
             {
                int len=read(cfd,buf,sizeof(buf) + 1);
                if(len>0) cout << " client data : " << buf << endl;
                else if(len == -1)
                {
                    perror("read");
                    exit(-1);
                }
                else cout << "client close ....." << endl;
                
                ret=write(cfd,buf,sizeof(buf));
                if(ret == 1)
                {
                    perror("write");
                    exit(-1);
                }
             }

             close(cfd);
        }
    }

    close(sfd);
    return 0;
}

Client code:

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

using namespace std;

int main()
{
    //create socket
    int cfd=socket(AF_INET,SOCK_STREAM,0);
    if(cfd==-1)
    {
        perror("scoket");
        exit(-1);
    }

    //connect to the server
    struct sockaddr_in serveraddr;
    serveraddr.sin_family=AF_INET;
    serveraddr.sin_port=htons(4002);
    inet_pton(AF_INET,"192.168.61.132", &serveraddr.sin_addr.s_addr);
    int ret=connect(cfd,(struct sockaddr *) & serveraddr, sizeof(serveraddr));
    if(ret==-1)
    {
        perror("connect");
        exit(-1);
    }

    //communication
    int i=1;
    char recvbuf[1024]={0};
    while(1)
    {
        sprintf(recvbuf,"data %d\
",i++);
        ret=write(cfd,recvbuf,strlen(recvbuf) + 1);
        if(ret==-1)
        {
            perror("write");
            exit(-1);
        }

        sleep(1);

        read(cfd, recvbuf, sizeof(recvbuf));
        cout << "recv data : " << recvbuf << endl;
    }

    close(cfd);
    return 0;
}

Multithreading

Server

#include <iostream>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>

using namespace std;

struct sockinfo{
    int fd;
    pthread_t tid;
    sockaddr_in caddr;
};

struct sockinfo sockinfos[128];

void * working(void * arg)
{
    struct sockinfo *pinfo=(struct sockinfo *)arg;
    char buf[1024]={0};
    while(1)
    {
                int len=read(pinfo->fd,buf,sizeof(buf));
                if(len>0) cout << " client data : " << buf << endl;
                else if(len == -1)
                {
                    perror("read");
                    exit(-1);
                }
                else cout << "client close ....." << endl;
                
                int ret=write(pinfo->fd,buf,strlen(buf) + 1);
                if(ret == -1)
                {
                    perror("write");
                    exit(-1);
                }
    }

    close(pinfo->fd);

    return NULL;
}

int main()
{
    //create socket
    int sfd=socket(AF_INET,SOCK_STREAM,0);
    if(sfd==-1)
    {
        perror("sock");
        exit(-1);
    }

    //bind
    struct sockaddr_in saddr;
    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(4002);
    saddr.sin_addr.s_addr=INADDR_ANY;
    int ret=bind(sfd,(struct sockaddr *) & saddr, sizeof(saddr));
    if(ret==-1)
    {
        perror("bind");
        exit(-1);
    }

    //monitor
    ret=listen(sfd,8);
    if(ret==-1)
    {
        perror("listen");
        exit(-1);
    }

    //initialization
        int maxv=sizeof(sockinfos)/sizeof(sockinfos[0]);
        for(int i=0;i<maxv;i++)
        {
            bzero( & amp; sockinfos, sizeof(sockinfos[i]));
            sockinfos[i].fd=-1;
        }

    while(1)
    {
        struct sockaddr_in cliaddr;
        socklen_t len=sizeof(cliaddr. sin_addr. s_addr);
        int cfd=accept(sfd,(struct sockaddr *) & amp;cliaddr, & amp;len);
        if(cfd==-1)
         {
            perror("accept");
            exit(-1);
        }

        struct sockinfo * pinfo;

        for(int i=0;i<maxv;i++)
        {
            if(sockinfos[i].fd==-1)
            {
                pininfo= &sockinfos[i];
                break;
            }
            if(i==maxv-1) {
                sleep(1);
                i=0;
            }
        }

        pinfo->fd=cfd;
        memcpy( & amp; pinfo->caddr, & amp; cliaddr, len);

        pthread_create( & pinfo->tid, NULL, working, pinfo);

        pthread_detach(pinfo->tid);
    }

    close(sfd);
    return 0;
}

The client code of multi-process and multi-thread is the same, and communication can be realized