linux下socket小型多线程服务端简单例子，多线程服务端编程

linux下socketk小型多线程服务端简单例子

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

static const int g_inValidfd = -1;
static int g_clientSocketfd[200];
static pthread_mutex_t g_client_mutex;

static void sig_exit(int sig)
{
    fprintf(stderr, "sig_exit:%d\n",sig);
    exit(0);
}

static void removeClient(int fd)
{
    int i=0;
    int count  = sizeof (g_clientSocketfd) / sizeof (g_clientSocketfd[0]);
    pthread_mutex_lock(&g_client_mutex);
    for(;i<count;i++){
        if(fd == g_clientSocketfd[i]){
            g_clientSocketfd[i] = g_inValidfd;
            break;
        }
    }
    pthread_mutex_unlock(&g_client_mutex);
}

static void* client_thread(void* arg)
{
    int iRet = 0;
    int iVar = 0x12345678;
    int clnt_sock = *((int*)arg);
    char buf[100]={0};

    while(1){
        //向客户端发送大端字节序
        iVar = htonl(iVar);
        iRet = write(clnt_sock,&iVar,sizeof (iVar));
        if(iRet < 1){
            printf("wqiRet=%d\n",iRet);
            break;
        }
        iRet = read(clnt_sock,buf,100);
        printf("recv=%s\n",buf);
        if(iRet < 1){
            printf("giRet=%d\n",iRet);
            break;
        }
        sleep(5);
    }
    removeClient(clnt_sock);
    close(clnt_sock);
    pthread_detach(pthread_self());

    return  NULL;
}

static int addClient(int fd)
{
    int i=0,iRet = -1;
    int count  = sizeof (g_clientSocketfd) / sizeof (g_clientSocketfd[0]);
    pthread_t th;
    pthread_mutex_lock(&g_client_mutex);
    for(;i<count;i++){
        if(g_inValidfd  == g_clientSocketfd[i]){
            g_clientSocketfd[i] = fd;
            if (pthread_create(&th, NULL, client_thread, (void*)(g_clientSocketfd+i)) != 0){
                perror("创建处理线程失败:");
                g_clientSocketfd[i] = g_inValidfd;
            }else{
                iRet = 0;
            }
            break;
        }
    }
    pthread_mutex_unlock(&g_client_mutex);
    return  iRet;
}

int main()
{
    int reuseaddr = 1;
    int retval = 0;
    int serv_sock = -1;
    int clnt_sock = -1;
    int max_client_count = 0;
    socklen_t clnt_addr_size;
    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;

    (void) signal(SIGUSR1, sig_exit);
    (void) signal(SIGCHLD, SIG_IGN);
    (void) signal(SIGTSTP, sig_exit);
    (void) signal(SIGINT, SIG_IGN);
    (void) signal(SIGPIPE, SIG_IGN);
    (void) signal(SIGKILL, sig_exit);
    (void) signal(SIGSEGV, sig_exit);

    pthread_mutex_init(&g_client_mutex, NULL);
    max_client_count = sizeof (g_clientSocketfd) / sizeof (g_clientSocketfd[0]);
    for(retval=0;retval<max_client_count;retval++){
        g_clientSocketfd[retval] = g_inValidfd;
    }

    serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(serv_sock < 1){
        perror("socket");
        return -1;
    }
    retval = setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,sizeof(reuseaddr));
    if (retval != 0) {
        perror("setsockopt: reuseaddr");
    }
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);//inet_addr("127.0.0.1");
    serv_addr.sin_port = htons(6666);
    retval = bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if (retval != 0) {
        perror("bind");
        return -1;
    }

    retval = listen(serv_sock, 200);
    if (retval != 0) {
        perror("listen");
        return -1;
    }

    clnt_addr_size = sizeof(clnt_addr);
    while(1)
    {
        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);
        if(-1 == addClient(clnt_sock)){
            close(clnt_sock);
        }
    }
    close(serv_sock);
    pthread_mutex_destroy(&g_client_mutex);
    return 0;
}