socket网络编程实现并发服务器——多线程

线程介绍

1，什么是线程

线程在操作系统原理中是这样描述的：线程是进程的一条执行路径。线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，所有的线程都是在同一进程空间运行，这也意味着多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境(register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。

2，主线程和子线程

一个进程创建后，会首先生成一个缺省的线程，通常称这个线程为主线程(或称控制线程)，C/C++程序中，主线程就是通过 main函数进入的线程，由主线程调用pthread_create()创建的线程称为子线程，子线程也可以有自己的入口函数，该函数由用户 在创建的时候指定。每个线程都有自己的线程ID，可以通过pthread_self()函数获取。

3，创建线程

函数原型：

#include 
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *),  void *arg);
Compile and link with -pthread.

（说明： pthreand_create()用来创建一个线程，并执行第三个参数start_routine所指向的函数。）

第三个参数start_routine是一个函数指针，它指向的函数原型是 void *func(void *)，这是所创建的子线程要执行的任务 （函数）；
第四个参数arg就是传给了所调用的函数的参数，如果有多个参数需要传递给子线程则需要封装到一个结构体里传进去； 第一个参数thread是一个pthread_t类型的指针，他用来返回该线程的线程ID。每个线程都能够通过pthread_self()来获取 自己的线程ID（pthread_t类型）。
第二个参数是线程的属性，其类型是pthread_attr_t类型，其定义如下：

typedef struct
 {     
         int                               detachstate;   线程的分离状态     
         int                               schedpolicy; 线程调度策略      
         struct sched_param                schedparam;  线程的调度参数    
         int                               inheritsched;  线程的继承性   
         int                               scope;       线程的作用域    
         size_t                            guardsize;   线程栈末尾的警戒缓冲区大小   
         int                               stackaddr_set;   
         void *                            stackaddr;   线程栈的位置     
         size_t                            stacksize；线程栈的大笑
  }
   

代码示例：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

typedef void *(THREAD_BODY) (void *thread_arg); 
void *thread_worker(void *ctx);
//封装thread_start()函数，实现创建子线程的功能
int thread_start(pthread_t * thread_id, THREAD_BODY * thread_workbody, 

void *thread_arg);     //帮助信息
{
       printf("%s usage: \n", progname);     
       printf("-p(--port): sepcify server listen port.\n");             
       printf("-h(--Help): print this help information.\n");

      return；
           
}
int main(int argc, char **argv)
{
       int                  sockfd = -1; 
       int                  rv = -1;
       struct sockaddr_in   servaddr; 
       struct sockaddr_in   cliaddr;
       socklen_t            len; 
       int                  port = 0;   
       int                  clifd;  
       int                  ch;  
       int                  on = 1;   
       pthread_t            tid;    //定义线程
       struct option        opts[] = {  
                     {"port", required_argument, NULL, 'p'},                  
                     {"help", no_argument, NULL, 'h'},                
                     {NULL, 0, NULL, 0}        };
}

while( (ch=getopt_long(argc, argv, "p:h", opts, NULL)) != -1 )       
 {               
           switch(ch)                
           {              
                     case 'p':                                
                             port=atoi(optarg);                                
                             break;
                     case 'h':                                 
                             print_usage(argv[0]);                                
                             return 0;             
           }
 }

  if( !port )           //判断端口连接
 {               
                 print_usage(argv[0]);                
                 return 0;     
  }
   sockfd=socket(AF_INET, SOCK_STREAM, 0);      
   if(sockfd < 0)      
   {             
              printf("Create socket failure: %s\n", strerror(errno));                
              return -1;     
    }      
    printf("Create socket[%d] successfully!\n", sockfd);

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    memset(&servaddr, 0, sizeof(servaddr));                 
    servaddr.sin_family=AF_INET;      
    servaddr.sin_port = htons(port);     
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); /* 监听所有 */ 
    //inet_aton("127.0.0.1", &servaddr.sin_addr) ；/*监听某个ip*/

      rv=bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));        
      if(rv < 0)       
       {                
               printf("Socket[%d] bind on port[%d] failure: %s\n", sockfd, port, strerror(errno));               
                 return -2;       
       }
          listen(sockfd, 13);       
         printf("Start to listen on port [%d]\n", port);
 
        while(1)       
         {               
                       printf("Start accept new client incoming...\n");
                       clifd=accept(sockfd, (struct sockaddr *)&cliaddr, &len);               
                       
                       if(clifd < 0)          
                       {                
                               printf("Accept new client failure: %s\n", strerror(errno));                       
                                continue;               
                      }
                      printf("Accept new client[%s:%d] successfully\n"，
inet_ntoa(cliaddr.sin_addr),ntohs(cliaddr.sin_port));
                      thread_start(&tid, thread_worker, (void *)clifd);        }
                      close(sockfd);
                       return 0;
}

int thread_start(pthread_t * thread_id, THREAD_BODY * thread_workbody, void *thread_arg) 
{
          int                 rv = -1;      
          pthread_attr_t      thread_attr;

 //线程初始化
  if( pthread_attr_init(&thread_attr) )      
  {             
         printf("pthread_attr_init() failure: %s\n", strerror(errno));                      
         goto CleanUp;      
   }
   
  if( pthread_attr_setstacksize(&thread_attr, 120*1024) )        
  {               
          printf("pthread_attr_setstacksize() failure: %s\n", strerror(errno));                
          goto CleanUp;        
   }
   if( pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED) )        
   {
          printf("pthread_attr_setdetachstate() failure: %s\n", strerror(errno));                
          goto CleanUp;       
     }
        /*创建线程*/       
      if( pthread_create(thread_id, &thread_attr, thread_workbody, thread_arg) )        
      {                
                    printf("Create thread failure: %s\n", strerror(errno));                
                    goto CleanUp;     
       }
        rv = 0;                                                    CleanUp:             
          /* 用完之后摧毁线程 */                           
          pthread_attr_destroy(&thread_attr);     
          return rv; 
          }

void *thread_worker(void *ctx) 
{        
               int                  clifd;        
               int                  rv;        
               char                 buf[1024];        
               int                  i;
        
    if( !ctx )       
     {               
      printf("Invalid input arguments in %s()\n", __FUNCTION__);                pthread_exit(NULL);       
       }
    clifd = (int)ctx;
        printf("Child thread start to commuicate with socket client...\n");
       
     while(1)        
     {               
           memset(buf, 0, sizeof(buf));               
           rv=read(clifd, buf, sizeof(buf));                
       if( rv < 0)                
       {                        
              printf("Read data from client sockfd[%d] failure: %s and thread will exit\n", clifd, strerror(errno));                          
              close(clifd);                       
              pthread_exit(NULL);                
              }               
        else if( rv == 0)                
        {                       
         printf("Socket[%d] get disconnected and thread will exit.\n", clifd);                        
         close(clifd);                        
         pthread_exit(NULL);                
         }                
         else if( rv > 0 )                
         {                        
         printf("Read %d bytes data from Server: %s\n", rv, buf);                      
         }
                /* convert letter from lowercase to uppercase */                    
         for(i=0; i<rv; i++)                
         {                        
               buf[i]=toupper(buf[i]);                
         }                               
         rv=write(clifd, buf, rv);                
         if(rv < 0)                
         {                        
                       printf("Write to client by sockfd[%d] failure: %s and thread will exit\n", clifd, strerror(errno));
                        
                        close(clifd);                        
                        pthread_exit(NULL);              
            }        
        }
   }

保存后再linux下运行：

4，线程与进程的区别与联系

1，关于多进程和多线程，“进程是资源分配的最小单位，线程是CPU调度的最小单位”。

2，多进程是指：当你运行一个程序，你就启动了一个进程。每个进程都有自己独立的地址空间(内存空间)，每当用户启动一个进程时，操作系统就会为该进程分配一个独立的内存空间，让应用程序在这个独立的内存空间中运行。
但是一个服务器程序抛开硬件（CPU、内存、带宽）限制以外，还会受到Linux系统的资源限制。所以，如果我们想要增 加Linux服务器并发访问的客户端数量，则需要在服务器程序里通过调用setrlimit()函数来修改这些限制。
3多线程是指：一个轻量级的子进程，是最小的处理单元；是一个单独的执行路径。可以说：线程是进程的子集（部分），一个进程可能由多个线程组成。线程是独立的。如果在一个线程中发生异常，则不会影响其他线程。它使用共享内存区域。
但是无论子线程执行完毕与否，一旦主线程执行完毕退出，所有 子线程执行都会终止。这时整个进程结束或僵死，部分线程保持一种终止执行但还未销毁的状态，而进程必须在其所有线程销毁 后销毁，这时进程处于僵死状态。