Linux下C编写基本的多线程socket服务器

不想多说什么，会搜这些东西的都是想看代码的吧。

一开始不熟悉多线程的时候还在想怎么来控制一个线程的结束，后来发现原来有pthread_exit()函数可以直接在线程函数内部调用结束这个线程。

开始还想初始化一个pthread_t thread_fd[MAX]数组来存储开启的线程，然后用一个栈存储那些未分配的数组元素（thread_fd[index]=0）的index，跟缓存的思维相似，不过实在是想多了。

废话不多说，直接上代码，服务器和客户端都已经编译通过，正常运行，有基本的容错能力，不过也只是最基本的。

服务器：

 /*
  * multi_thread_socket_server.c
  *
  *  Created on: Mar 14, 2014
  *      Author: nerohwang
  */
 #include<stdlib.h>
 #include<pthread.h>
 #include<sys/socket.h>
 #include<sys/types.h>       //pthread_t , pthread_attr_t and so on.
 #include<stdio.h>
 #include<netinet/in.h>      //structure sockaddr_in
 #include<arpa/inet.h>       //Func : htonl; htons; ntohl; ntohs
 #include<assert.h>          //Func :assert
 #include<string.h>          //Func :memset
 #include<unistd.h>          //Func :close,write,read
 #define SOCK_PORT 9988
 #define BUFFER_LENGTH 1024
 #define MAX_CONN_LIMIT 512     //MAX connection limit

 static void Data_handle(void * sock_fd);   //Only can be seen in the file

 int main()
 {
     int sockfd_server;
     int sockfd;
     int fd_temp;
     struct sockaddr_in s_addr_in;
     struct sockaddr_in s_addr_client;
     int client_length;

     sockfd_server = socket(AF_INET,SOCK_STREAM,);  //ipv4,TCP
     assert(sockfd_server != -);

     //before bind(), set the attr of structure sockaddr.
     memset(&s_addr_in,,sizeof(s_addr_in));
     s_addr_in.sin_family = AF_INET;
     s_addr_in.sin_addr.s_addr = htonl(INADDR_ANY);  //trans addr from uint32_t host byte order to network byte order.
     s_addr_in.sin_port = htons(SOCK_PORT);          //trans port from uint16_t host byte order to network byte order.
     fd_temp = bind(sockfd_server,(struct scokaddr *)(&s_addr_in),sizeof(s_addr_in));
     if(fd_temp == -)
     {
         fprintf(stderr,"bind error!\n");
         exit();
     }

     fd_temp = listen(sockfd_server,MAX_CONN_LIMIT);
     if(fd_temp == -)
     {
         fprintf(stderr,"listen error!\n");
         exit();
     }

     while()
     {
         printf("waiting for new connection...\n");
         pthread_t thread_id;
         client_length = sizeof(s_addr_client);

         //Block here. Until server accpets a new connection.
         sockfd = accept(sockfd_server,(struct sockaddr_*)(&s_addr_client),(socklen_t *)(&client_length));
         if(sockfd == -)
         {
             fprintf(stderr,"Accept error!\n");
             continue;                               //ignore current socket ,continue while loop.
         }
         printf("A new connection occurs!\n");
         if(pthread_create(&thread_id,NULL,(void *)(&Data_handle),(void *)(&sockfd)) == -)
         {
             fprintf(stderr,"pthread_create error!\n");
             break;                                  //break while loop
         }
     }

     //Clear
     int ret = shutdown(sockfd_server,SHUT_WR); //shut down the all or part of a full-duplex connection.
     assert(ret != -);

     printf("Server shuts down\n");
     return ;
 }

 static void Data_handle(void * sock_fd)
 {
     int fd = *((int *)sock_fd);
     int i_recvBytes;
     char data_recv[BUFFER_LENGTH];
     const char * data_send = "Server has received your request!\n";

     while()
     {
         printf("waiting for request...\n");
         //Reset data.
         memset(data_recv,,BUFFER_LENGTH);

         i_recvBytes = read(fd,data_recv,BUFFER_LENGTH);
         if(i_recvBytes == )
         {
             printf("Maybe the client has closed\n");
             break;
         }
         if(i_recvBytes == -)
         {
             fprintf(stderr,"read error!\n");
             break;
         }
         if(strcmp(data_recv,"quit")==)
         {
             printf("Quit command!\n");
             break;                           //Break the while loop.
         }
         printf("read from client : %s\n",data_recv);
         if(write(fd,data_send,strlen(data_send)) == -)
         {
             break;
         }
     }

     //Clear
     printf("terminating current client_connection...\n");
     close(fd);            //close a file descriptor.
     pthread_exit(NULL);   //terminate calling thread!
 }

外加客户端:

 /*
  * socket_client.c
  *
  *  Created on: Mar 15, 2014
  *      Author: nerohwang
  */
 #include<stdlib.h>
 #include<sys/socket.h>
 #include<sys/types.h>       //pthread_t , pthread_attr_t and so on.
 #include<stdio.h>
 #include<netinet/in.h>      //structure sockaddr_in
 #include<arpa/inet.h>       //Func : htonl; htons; ntohl; ntohs
 #include<assert.h>          //Func :assert
 #include<string.h>          //Func :memset
 #include<unistd.h>          //Func :close,write,read
 #define SOCK_PORT 9988
 #define BUFFER_LENGTH 1024
 int main()
 {
     int sockfd;
     int tempfd;
     struct sockaddr_in s_addr_in;
     char data_send[BUFFER_LENGTH];
     char data_recv[BUFFER_LENGTH];
     memset(data_send,,BUFFER_LENGTH);
     memset(data_recv,,BUFFER_LENGTH);

     sockfd = socket(AF_INET,SOCK_STREAM,);       //ipv4,TCP
     if(sockfd == -)
     {
         fprintf(stderr,"socket error!\n");
         exit();
     }

     //before func connect, set the attr of structure sockaddr.
     memset(&s_addr_in,,sizeof(s_addr_in));
     s_addr_in.sin_addr.s_addr = inet_addr("127.0.0.1");      //trans char * to in_addr_t
     s_addr_in.sin_family = AF_INET;
     s_addr_in.sin_port = htons(SOCK_PORT);

     tempfd = connect(sockfd,(struct sockaddr *)(&s_addr_in),sizeof(s_addr_in));
     if(tempfd == -)
     {
         fprintf(stderr,"Connect error! \n");
         exit();
     }

     while()
     {
         printf("Please input something you wanna say(input \"quit\" to quit):\n");
         gets(data_send);
         //scanf("%[^\n]",data_send);         //or you can also use this
         tempfd = write(sockfd,data_send,BUFFER_LENGTH);
         if(tempfd == -)
         {
             fprintf(stderr,"write error\n");
             exit();
         }

         if(strcmp(data_send,"quit") == )  //quit,write the quit request and shutdown client
         {
             break;
         }
         else
         {
             tempfd = read(sockfd,data_recv,BUFFER_LENGTH);
             assert(tempfd != -);
             printf("%s\n",data_recv);
             memset(data_send,,BUFFER_LENGTH);
             memset(data_recv,,BUFFER_LENGTH);
         }
     }

     int ret = shutdown(sockfd,SHUT_WR);       //or you can use func close()--<unistd.h> to close the fd
     assert(ret != -);
     return ;
 }