多线程、多进程TCP服务器比较

关于进程和线程
1.线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
3.进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见；
4.调度和切换：线程上下文切换比进程上下文切换要快得多。

使用多线程和多进程时性能的对比：

一、多进程服务器：
多进程服务器端代码演示：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<netinet/in.h>

int startup(char*ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock<0)
    {
        perror("socket");
        exit(0);
    }

    struct sockaddr_in local;
    local.sin_family =AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock, (struct sockaddr*)&local, sizeof(local))<0)
    {
        perror("bind");
        exit(2);
    }

    if(listen(sock, 10)<0)
    {
        perror("listen");
        exit(3);
    }
    return sock;
}

void usage(const char* proc)
{
    printf("usage: %s [local_ip] [local_ip]\n", proc);
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(4);
    }

    int listen_sock = startup(argv[1],atoi(argv[2]));
    printf("fd:%d\n", listen_sock);
    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if(new_sock<0)
        {
            perror("accept");
            continue;
        }

        printf("get a client:[%s: %d]\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

        pid_t id = fork();
        if(id < 0)
        {
            close(new_sock);
            continue;
        }
        else if(id == 0) //child
        {
            close(listen_sock);
            if(fork() > 0)  //child->child
            {
                exit(0);
            }

            char buf[1024];
            while(1)
            {
                ssize_t s = read(new_sock, buf, sizeof(buf)-1);
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("client# %s\n", buf);
                }
                else if(s == 0)
                {
                    printf("client quit!\n");
                    break;
                }
                else
                {
                    perror("read");
                    break;
                }
            }
            close(new_sock);
            exit(0);
        }
        else  //father
        {
            close(new_sock);
            waitpid(id, NULL, 0);
        }
    }
    return 0;
}

多进程客户端代码（client.c）：

#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<netinet/in.h>

void usage(const char* proc)
{
    printf("usage: %s [local_ip] [local_ip]\n", proc);
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }

    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        exit(2);
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
    {
        perror("connect");
        exit(2);
    }
    while(1)
    {
        printf("please enter# ");
        fflush(stdout);

        char buf[1024];
        ssize_t rd = read(0, buf, sizeof(buf)-1);
        if(rd > 0)
        {
            buf[rd-1] = 0;
            write(sock, buf, strlen(buf));
        }
    }
   return 0;
}

运行服务器

客户端启动

用telnet工具模拟另一个客户端

二、多线程服务器：
多线程服务器端代码演示：

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<fcntl.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<pthread.h>

int startup(char* ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("sock");
        exit(1);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        perror("bind");
        exit(2);
    }

    if(listen(sock, 10)<0)
    {
        perror("listen");
        exit(3);
    }
    return sock;
}

void usage(const char* proc)
{
    printf("usage:%s [local_ip] [local_port]\n", proc);
}

void* request(void* arg)
{
    int new_sock =(int)arg;
    while(1)
    {
        char buf[1024];
        ssize_t s = read(new_sock, buf, sizeof(buf)-1);
        if(s>0)
        {
            buf[s] = 0;
            printf("client# %s\n", buf);

//            printf("please enter#");
//            fflush(stdout);
//            read(0,buf,sizeof(buf)-1);
//            write(new_sock, buf, strlen(buf));

        }
        else if(s == 0)
        {
            printf("client is quit!\n");
            break;
        }
        else
        {
            perror("read");
            exit(5);
        }
    }
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
    }

    int listen_sock = startup(argv[1], atoi(argv[2]));
    printf("fd: %d\n", listen_sock);

    while(1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int new_sock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if(new_sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("get a client:%s, %d\n",inet_ntoa(client.sin_addr), ntohs(client.sin_port));

        pthread_t tid;
        pthread_create(&tid, NULL, request, (void*)new_sock);
        pthread_detach(tid);
        close(new_sock);
    }
    close(listen_sock);
    return 0;
}

客户端代码同多进程

运行演示

三、bind失败的原因：

原因分析：
服务器的一方与客户端断开连接，会发送FIN信号给客户端，客户端给一个确认ACK信号返回给服务器，但连接是两边的事，此时客户端一方的连接没有断开，四次挥手(http://blog.csdn.net/m0_37968340/article/details/73758082)还没有完成，所以连接没有断开，处于TIME_WAIT状态。

解决方法：在bind设置SO_REUSEADDR套接字选项。

const int on=1;

setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));

之后再次重复上述重启操作，重启成功。

l SO_REUSEADDR选项

SO_REUSEADDR选项的用途有多中，我们只讨论这里使用到的功能。先来看看UNP V1对这种情况的描述。

SO_REUSEADDR允许启动一个监听服务器并捆绑其众所周知端口，即使以前建立的将该端口用作它们的本地的连接仍存在。这个条件通常是这样碰到的：

(1) 启动一个监听服务器；

(2) 连接请求到达，派生一个子进程来处理这个客户；

(3) 监听服务器终止，但子进程继续为现有连接上的客户提供服务；

(4) 重启监听服务器。

默认情况下，当监听服务器在步骤(4)中通过调用socket、bind和listen重新启动时，由于它试图捆绑一个现有连接（即正由早先派生的那个子进程处理着的连接）上的端口，从而bind调用会失败。但如果该服务器在socket和bind中间调用设置了SO_REUSEADDR选项，那么bind将成功。 ——以上摘自UNP V1