Chinaunix首页 | 论坛 | 博客

_小林_

首页　| 　博文目录　| 　关于我

SCUT_Lin

  • 博客访问： 64234
  • 博文数量： 21
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 236
  • 用 户 组： 普通用户
  • 注册时间： 2014-09-05 21:34
文章分类

全部博文（21）

文章存档

2015年（21）

我的朋友
最近访客
推荐博文
相关博文
一个简单的wed服务器SHTTPD（3）————SHTTPD多客户端支持的实现

分类： LINUX

2015-08-07 23:53:36


点击(此处)折叠或打开

  1. //start from the very beginning,and to create greatness
  2. //@author: Chuangwei Lin
  3. //@E-mail：979951191@qq.com
  4. //@brief： SHTTPD多客户端支持的实现

  6. #include "lcw_shttpd.h"
  7. static int workersnum = 0;//工作线程的数量
  8. extern struct conf_opts conf_para;
  9. pthread_mutex_t thread_init = PTHREAD_MUTEX_INITIALIZER;//这里就已经初始化了互斥锁
  10. int WORKER_ISSTATUS(int status);
  11. static struct worker_ctl *wctls = NULL;//线程选项
  12. void Worker_Init();
  13. int Worker_Add(int i);
  14. void Worker_Delete(int i);
  15. void Worker_Destory();
  16. /******************************************************
  17. 函数名：do_work(struct worker_ctl *wctl)
  18. 参数：控制结构
  19. 功能：执行任务
  20. *******************************************************/
  21. static void do_work(struct worker_ctl *wctl)
  22. {
  23.     DBGPRINT("LCW==>do_work\n");
  24.     struct timeval tv;        //超时时间
  25.     fd_set rfds;            //读文件集
  26.     int fd = wctl->conn.cs;//客户端的套接字描述符
  27.     struct vec *req = &wctl->conn.con_req.req;//请求缓冲区向量
  28.     
  29.     int retval = 1;//返回值

  31.     for(;retval > 0;)
  32.     {
  33.         FD_ZERO(&rfds);    //清读文件集
  34.         FD_SET(fd, &rfds);//将客户端连接描述符放入读文件集
  35.         //设置超时
  36.         tv.tv_sec = 300;//conf_para.TimeOut;
  37.         tv.tv_usec = 0;
  38.         //超时读数据
  39.         retval = select(fd + 1, &rfds, NULL, NULL, &tv);
  40.         switch(retval)
  41.         {
  42.             case -1://错误
  43.                 close(fd);
  44.                 break;
  45.             case 0://超时
  46.                 close(fd);
  47.                 break;
  48.             default:
  49.                 printf("select retval:%d\n",retval);
  50.                 if(FD_ISSET(fd, &rfds))//检测文件
  51.                 {
  52.                     memset(wctl->conn.dreq, 0, sizeof(wctl->conn.dreq));
  53.                     //读取客户端数据
  54.                     req->len = read(wctl->conn.cs, wctl->conn.dreq, sizeof(wctl->conn.dreq));
  55.                     req->ptr = wctl->conn.dreq;
  56.                     DBGPRINT("Read %d bytes,'%s'\n",req->len,req->ptr);
  57.                     if(req->len > 0)
  58.                     {
  59.                         //分析客户端的数据
  60.                         wctl->conn.con_req.err = Request_Parse(wctl);//待实现
  61.                         //处理并响应客户端请求
  62.                         Request_Handle(wctl);//待实现                
  63.                     }
  64.                     else
  65.                     {
  66.                         close(fd);
  67.                         retval = -1;
  68.                     }
  69.                 }
  70.         }
  71.     }
  72.     DBGPRINT("LCW<==do_work\n");
  73. }

  75. /******************************************************
  76. 函数名：worker(void *arg)
  77. 参数：worker_ctl *wctls
  78. 功能：线程处理函数
  79. *******************************************************/
  80. static void* worker(void *arg)
  81. {
  82.     DBGPRINT("LCW==>worker\n");
  83.     struct worker_ctl *ctl = (struct worker_ctl *)arg;//为何不直接传这个类型过来？
  84.     struct worker_opts *self_opts = &ctl->opts;//定义一个选项结构
  85.     pthread_mutex_unlock(&thread_init);//解锁互斥
  86.     self_opts->flags = WORKER_IDEL;//初始化线程为空闲，等待任务
  87.     //如果主控线程没有让此线程退出，则循环处理任务
  88.     for(;self_opts->flags != WORKER_DETACHING;)//while(self_opts->flags != WORKER_DETACHING)
  89.     {
  90.         //DBGPRINT("work:%d,status:%d\n",(int)self_opts->th,self_opts->flags );
  91.         //查看是否有任务分配
  92.         int err = pthread_mutex_trylock(&self_opts->mutex);//互斥预锁定
  93.         //pthread_mutex_trylock()是pthread_mutex_lock() 的非阻塞版本
  94.         if(err)
  95.         {
  96.             //DBGPRINT("NOT LOCK\n");
  97.             sleep(1);
  98.             continue;
  99.         }
  100.         else
  101.         {
  102.             //有任务，do it
  103.             DBGPRINT("Do task\n");
  104.             self_opts->flags = WORKER_RUNNING;//执行标志
  105.             do_work(ctl);
  106.             close(ctl->conn.cs);//关闭套接字
  107.             ctl->conn.cs = -1;
  108.             if(self_opts->flags == WORKER_DETACHING)
  109.                 break;
  110.             else
  111.                 self_opts->flags = WORKER_IDEL;
  112.         }
  113.     }
  114.     //主控发送退出命令
  115.     //设置状态为已卸载
  116.     self_opts->flags = WORKER_DETACHED;
  117.     workersnum--;//工作线程-1

  119.     DBGPRINT("LCW<==worker\n");
  120.     return NULL;
  121. }
  122. /******************************************************
  123. 函数名：WORKER_ISSTATUS(int status)
  124. 参数：欲查询的线程状态
  125. 功能：查询线程状态
  126. *******************************************************/
  127. int WORKER_ISSTATUS(int status)
  128. {
  129.     int i = 0;
  130.     for(i = 0; i<conf_para.MaxClient;i++)
  131.     {
  132.         if(wctls[i].opts.flags == status)
  133.             return i;//返回符合的线程
  134.     }
  135.     return -1;//没有符合的线程状态
  136. }
  137. /*****************************************************
  138. 函数名：Worker_Init()
  139. 参数：无
  140. 功能：初始化线程    
  141. ******************************************************/
  142. void Worker_Init()
  143. {
  144.     DBGPRINT("LCW==>Worker_Init");
  145.     int i = 0;
  146.     //初始化总控参数
  147.     wctls = (struct worker_ctl*)malloc( sizeof(struct worker_ctl)*conf_para.MaxClient);//开辟空间
  148.     memset(wctls,0, sizeof(*wctls)*conf_para.MaxClient);//清零
  149.     //初始化一些参数
  150.     for(i=0;i<conf_para.MaxClient;i++)
  151.     {
  152.         //opt&connn结构和worker_ctl结构形成回指针
  153.         wctls[i].opts.work = &wctls[i];
  154.         wctls[i].conn.work = &wctls[i];
  155.         //opts结构部分的初始化
  156.         wctls[i].opts.flags = WORKER_DETACHED;
  157.         //wctls[i].opts.mutex = PTHREAD_MUTEX_INITIALIZER;
  158.         pthread_mutex_init(&wctls[i].opts.mutex,NULL);//初始化互斥锁
  159.         pthread_mutex_lock(&wctls[i].opts.mutex);
  160.         //conn部分的初始化
  161.         //con_req&con_res与conn结构形成回指
  162.         wctls[i].conn.con_req.conn = &wctls[i].conn;
  163.         wctls[i].conn.con_res.conn = &wctls[i].conn;
  164.         wctls[i].conn.cs = -1;//客户端socket连接为空
  165.         //conn.con_req部分初始化:请求结构
  166.         wctls[i].conn.con_req.req.ptr = wctls[i].conn.dreq;
  167.         wctls[i].conn.con_req.head = wctls[i].conn.dreq;
  168.         wctls[i].conn.con_req.uri = wctls[i].conn.dreq;
  169.         //conn.con_res部分初始化：响应结构
  170.         wctls[i].conn.con_res.fd = -1;
  171.         wctls[i].conn.con_res.res.ptr = wctls[i].conn.dres;

  173.     }    
  174.     for (i = 0; i < conf_para.InitClient;i++)
  175.     {
  176.         //增加规定个数工作线程
  177.         Worker_Add(i);
  178.     }
  179.     DBGPRINT("LCW<==Worker_Init\n");
  180. }

  182. /******************************************************
  183. 函数名：Worker_Add(int i)
  184. 参数：
  185. 功能：增加线程
  186. *******************************************************/
  187. int Worker_Add(int i)
  188. {
  189.     DBGPRINT("LCW==>Worker_Add\n");
  190.     pthread_t th;//线程参数
  191.     int err = -1;//返回值
  192.     if (wctls[i].opts.flags == WORKER_RUNNING)
  193.     {
  194.         return 1;//如果线程已经在工作，则返回
  195.     }
  196.     pthread_mutex_lock(&thread_init);//进入互斥区（之前有初始化过了）
  197.     wctls[i].opts.flags = WORKER_INITED;//状态为已初始化
  198.     err = pthread_create(&th, NULL, worker, (void*)&wctls[i]);//建立线程
  199.     //线程处理函数为worker
  200.     pthread_mutex_unlock(&thread_init);//解锁互斥
  201.     //更新线程选项    
  202.     wctls[i].opts.th = th;//线程ID
  203.     workersnum++;//线程数量增加1

  205.     DBGPRINT("LCW<==Worker_Add\n");
  206.     return 0;
  207. }


  210. /******************************************************
  211. 函数名：Worker_Delete(int i)
  212. 参数：线程序号
  213. 功能：减少线程
  214. *******************************************************/
  215. void Worker_Delete(int i)
  216. {
  217.     DBGPRINT("LCW==>Worker_Delete\n");
  218.     wctls[i].opts.flags = WORKER_DETACHING;//线程状态改为正在卸载
  219.     DBGPRINT("LCW<==Worker_Delete\n");
  220. }
  221. /******************************************************
  222. 函数名：Worker_Destory()
  223. 参数：
  224. 功能：销毁线程
  225. *******************************************************/
  226. void Worker_Destory()
  227. {
  228.     DBGPRINT("LCW==>Worker_Destory\n");
  229.     int i = 0;
  230.     int clean = 0;
  231.     
  232.     for(i=0;i<conf_para.MaxClient;i++)
  233.     {
  234.         DBGPRINT("thread %d,status %d\n",i,wctls[i].opts.flags );
  235.         if(wctls[i].opts.flags != WORKER_DETACHED)//如果状态不是已经卸载
  236.             Worker_Delete(i);
  237.     }

  239.     while(!clean)
  240.     {
  241.         clean = 1;
  242.         for(i = 0; i<conf_para.MaxClient;i++)
  243.         {
  244.             DBGPRINT("thread %d,status %d\n",i,wctls[i].opts.flags );
  245.             if(wctls[i].opts.flags == WORKER_RUNNING || wctls[i].opts.flags == WORKER_DETACHING)
  246.                 clean = 0;
  247.         }
  248.         if(!clean)
  249.             sleep(1);
  250.     }
  251.     DBGPRINT("LCW<==Worker_Destory\n");
  252. }

  254. //定义调度状态
  255. #define STATUS_RUNNING 1
  256. #define STATSU_STOP 0
  257. static int SCHEDULESTATUS = STATUS_RUNNING;
  258. /******************************************************
  259. 函数名：Worker_ScheduleRun(int ss)
  260. 参数：文件描述符
  261. 功能：当有客户端连接到来的时候，将客户端连接分配给空闲客户端，由客户端处理到来的请求
  262. *******************************************************/
  263. int Worker_ScheduleRun(int ss)
  264. {
  265.     DBGPRINT("LCW==>Worker_ScheduleRun!!!\n");
  266.     struct sockaddr_in client;
  267.     socklen_t len = sizeof(client);
  268.     //初始化线程服务
  269.     Worker_Init();

  271.     int i = 0;

  273.     for(;SCHEDULESTATUS== STATUS_RUNNING;)
  274.     {
  275.         struct timeval tv;//超时时间
  276.         fd_set rfds;//读文件集
  277.         //printf("SCHEDULESTATUS:%d\n",SCHEDULESTATUS);
  278.         int retval = -1;//返回值    
  279.         FD_ZERO(&rfds);    //清读文件集,将客户端连接
  280.         FD_SET(ss, &rfds);//描述符放入读文件集
  281.         //设置超时
  282.         tv.tv_sec = 0;
  283.         tv.tv_usec = 500000;
  284.         //超时读数据
  285.         retval = select(ss + 1, &rfds, NULL, NULL, &tv);
  286.         switch(retval)
  287.         {
  288.             case -1://错误
  289.             case 0://超时
  290.                 continue;
  291.                 break;
  292.             default:
  293.                 if(FD_ISSET(ss, &rfds))//检测文件
  294.                 {
  295.                     int sc = accept(ss, (struct sockaddr*)&client, &len);
  296.                     printf("client comming\n");//接受请求
  297.                     i = WORKER_ISSTATUS(WORKER_IDEL);//查找空闲业务处理线程
  298.                     if(i == -1)
  299.                     {
  300.                         i = WORKER_ISSTATUS(WORKER_DETACHED);//没有找到
  301.                         if(i != -1)
  302.                             Worker_Add(i);//增加一个业务处理线程
  303.                     }
  304.                     if(i != -1)//业务处理线程空闲，分配任务
  305.                     {
  306.                         wctls[i].conn.cs = sc;//套接字描述符
  307.                         pthread_mutex_unlock(&wctls[i].opts.mutex);//告诉业务线程有任务
  308.                     }                
  309.                 }
  310.         }        
  311.     }
  312.     
  313.     DBGPRINT("LCW<==Worker_ScheduleRun\n");
  314.     return 0;
  315. }
  316. /******************************************************
  317. 函数名：Worker_ScheduleStop()
  318. 参数：
  319. 功能：停止调度过程
  320. *******************************************************/
  321. int Worker_ScheduleStop()
  322. {
  323.     DBGPRINT("LCW==>Worker_ScheduleStop\n");
  324.     SCHEDULESTATUS = STATSU_STOP;//给任务分配线程设置终止条件
  325.     int i =0;
  326.     Worker_Destory();//销毁业务线程
  327.     int allfired = 0;
  328.     for(;!allfired;)//查询并等待业务线程终止
  329.     {
  330.         allfired = 1;
  331.         for(i = 0; i<conf_para.MaxClient;i++)
  332.         {
  333.             int flags = wctls[i].opts.flags;
  334.             if(flags == WORKER_DETACHING || flags == WORKER_IDEL)//线程正活动
  335.                 allfired = 0;
  336.         }
  337.     }
  338.     
  339.     pthread_mutex_destroy(&thread_init);//销毁互斥变量
  340.     for(i = 0; i<conf_para.MaxClient;i++)
  341.         pthread_mutex_destroy(&wctls[i].opts.mutex);//销毁业务吃力线程的互斥
  342.     free(wctls);//销毁业务数据
  343.     
  344.     DBGPRINT("LCW<==Worker_ScheduleStop\n");
  345.     return 0;
  346. }

阅读(1236) | 评论(0) | 转发(0) |
0

上一篇： 一个简单的wed服务器SHTTPD（2）———— 客户端请求分析

下一篇： 一个简单的wed服务器SHTTPD（4）————SHTTPD支持CGI的实现

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6