Chinaunix首页 | 论坛 | 博客

路漫漫vincent.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

vincent-cws

  • 博客访问： 956856
  • 博文数量： 116
  • 博客积分： 3923
  • 博客等级： 中校
  • 技术积分： 1337
  • 用 户 组： 普通用户
  • 注册时间： 2009-04-23 01:22
文章分类

全部博文（116）

文章存档

2013年（1）

2012年（17）

2011年（69）

2009年（29）

我的朋友
最近访客
推荐博文
相关博文
线程池实现

分类： WINDOWS

2011-11-07 00:01:06

今天终于花了整个下午时间把这个线程池实现了，今后应该会经常用到这个模块代码，贴出来分享一下。。。

继续修改了一下，加入了notifier通知函数。。。


file: main.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * @2011-11-06: initial
  5.  * @2011-11-13: add the notifier to register
  6.  */

  8. #include "threadpool.h"
  9. #include "stdio.h"

  11. #ifdef WIN32
  12. #define __lockx(lock)            EnterCriticalSection(&(lock))
  13. #define __unlockx(lock)            LeaveCriticalSection(&(lock))
  14. #define __lockx_init(lock,attr) InitializeCriticalSection(&(lock))
  15. #define __lockx_exit(lock,attr) DeleteCriticalSection(&(lock))
  16. #endif

  18. static lock_t lock;

  20. void thrd_hook_1(void *pdata)
  21. {
  22.     __lockx(lock);
  23.     printf("thrd_hook_1 running ...\n");
  24.     fflush(stdout);
  25.     __unlockx(lock);
  26. }

  28. void thrd_hook_2(void *pdata)
  29. {
  30.     __lockx(lock);
  31.     printf("thrd_hook_2 running ...\n");
  32.     fflush(stdout);
  33.     __unlockx(lock);
  34. }

  36. void thrd_hook_3(void *pdata)
  37. {
  38.     __lockx(lock);
  39.     printf("thrd_hook_3 running ...\n");
  40.     fflush(stdout);
  41.     __unlockx(lock);
  42. }

  44. void thrd_hook_4(void *pdata)
  45. {
  46.     __lockx(lock);
  47.     printf("thrd_hook_4 running ...\n");
  48.     fflush(stdout);
  49.     __unlockx(lock);
  50. }

  52. static int notifierx_call_test1(struct notifierx_block *pnb, unsigned long nlen, const void *pdata)
  53. {
  54.     thrd_msg_t *pmsg=(thrd_msg_t*)pdata;
  55.     __lockx(lock);
  56.     printf("-- fun: %s, nlen: %d, handle:%08x, state: %s --\n",
  57.         "notifierx_call_test1", nlen, pmsg->h, pmsg->stat==stat_busy?"busy":"free");
  58.     fflush(stdout);
  59.     __unlockx(lock);    
  60.     return 0;
  61. }

  63. static int notifierx_call_test2(struct notifierx_block *pnb, unsigned long nlen, const void *pdata)
  64. {
  65.     thrd_msg_t *pmsg=(thrd_msg_t*)pdata;
  66.     __lockx(lock);
  67.     printf("-- fun: %s, nlen: %d, handle:%08x, state: %s --\n",
  68.         "notifierx_call_test2", nlen, pmsg->h, pmsg->stat==stat_busy?"busy":"free");
  69.     fflush(stdout);
  70.     __unlockx(lock);    
  71.     return 0;
  72. }

  74. static int notifierx_call_test3(struct notifierx_block *pnb, unsigned long nlen, const void *pdata)
  75. {
  76.     thrd_msg_t *pmsg=(thrd_msg_t*)pdata;
  77.     __lockx(lock);
  78.     printf("-- fun: %s, nlen: %d, handle:%08x, state: %s --\n",
  79.         "notifierx_call_test3", nlen, pmsg->h, pmsg->stat==stat_busy?"busy":"free");
  80.     fflush(stdout);
  81.     __unlockx(lock);    
  82.     return 0;
  83. }

  85. #define NB_INIT(nb,f) ((nb).notifierx_call=(f))

  87. void main()
  88. {
  89.     thrdpool_t* pthrdpool = thrdpool();
  90.     thrd_handle h1,h2,h3,h4;
  91.     notifierx_block_t nb1,nb2,nb3;

  93.     NB_INIT(nb1,notifierx_call_test1);
  94.     NB_INIT(nb2,notifierx_call_test2);
  95.     NB_INIT(nb3,notifierx_call_test3);

  97.     __lockx_init(lock,0);
  98.     
  99.     thrdpool_init(6);

  101.     pthrdpool->ops.reg_notifier(&nb1);
  102.     pthrdpool->ops.reg_notifier(&nb2);
  103.     pthrdpool->ops.reg_notifier(&nb3);
  104.     pthrdpool->ops.unreg_notifier(&nb1);
  105.     
  106.     pthrdpool->ops.query();

  108.     h1=pthrdpool->ops.thrd_alloc(thrd_hook_1, 0);
  109.     pthrdpool->ops.query();
  110.     h2=pthrdpool->ops.thrd_alloc(thrd_hook_2, 0);
  111.     pthrdpool->ops.query();
  112.     pthrdpool->ops.wakeup(h2);
  113.     h3=pthrdpool->ops.thrd_alloc(thrd_hook_3, 0);
  114.     pthrdpool->ops.query();
  115.     h4=pthrdpool->ops.thrd_alloc(thrd_hook_4, 0);
  116.     pthrdpool->ops.query();
  117.     pthrdpool->ops.wakeup(h2);
  118.     Sleep(1000);
  119.     pthrdpool->ops.thrd_free(h2);
  120.     pthrdpool->ops.thrd_del(h1);
  121.     pthrdpool->ops.query();
  122.     pthrdpool->ops.wakeup(h2);
  123.     pthrdpool->ops.wakeup(h4);
  124.     pthrdpool->ops.wakeup(h4);
  125.     pthrdpool->ops.wakeup(h3);
  126.     pthrdpool->ops.wakeup(h3);
  127.     pthrdpool->ops.thrd_del(h2);
  128.     pthrdpool->ops.thrd_del(h3);
  129.     pthrdpool->ops.thrd_del(h4);
  130.     Sleep(1000);
  131.     pthrdpool->ops.query();
  132.     pthrdpool->ops.thrd_add();
  133.     pthrdpool->ops.query();

  135.     thrdpool_exit();
  136.     __lockx_exit(lock,0);

  138. }

file: threadpool.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * @2011-11-06: initial
  5.  * @2011-11-13: add the notifier to register
  6.  */

  8. #ifndef _THREADPOOL_H_
  9. #define _THREADPOOL_H_


  12. #include "list.h"

  14. #include "notifierx.h"

  16. #ifdef WIN32
  17. # include "windows.h"
  18. #else
  19. # include <pthread.h>
  20. #endif


  23. #define null (void*)0
  24. #define NULL (void*)0



  28. #ifndef __assert
  29. #define __assert(x)
  30. #endif


  33. #ifdef WIN32
  34. #    define thrd_handle    HANDLE
  35. #    define event_t        HANDLE
  36. #    define lock_t        CRITICAL_SECTION
  37. #    define attr_t        void*
  38. #else
  39. #    define thrd_handle    pthread_t
  40. #    define event_t        pthread_cond_t
  41. #    define lock_t        pthread_mutex_t
  42. #    define attr_t        pthread_mutexattr_t
  43. #endif

  45. typedef void (*thrd_hook_t)(void *pdata);

  47. #define stat_busy    1
  48. #define stat_free    2

  50. typedef struct thrd_msg_s{
  51.     thrd_handle h;
  52.     int stat;
  53.     void* v;
  54. }thrd_msg_t;

  56. #define INIT_THRD_MSG(st,hdl) \
  57. {\
  58.     (st).h=(hdl); \
  59.     (st).stat=stat_free;\
  60. }
  61. #define SET_THRD_STAT(st,s) \
  62. {\
  63.     (st).stat=(s);\
  64. }
  65. #define ST_SIZE_AND_VAL(st) sizeof(st),&(st)

  67. #define call_chain(chain,st,s) \
  68. {    \
  69.     SET_THRD_STAT((st), (s)); \
  70.     notifierx_call_chain(&(chain), ST_SIZE_AND_VAL(st)); \
  71. }


  74. typedef struct thrd_desc_s{
  75.     thrd_handle h;
  76.     thrd_hook_t thrd_hook;
  77.     void *pthrd_data;
  78.     event_t hevent_go;
  79.     event_t hevent_exit;
  80.     lock_t cslock;
  81.     struct list_head list;
  82.     unsigned int ref_cnts;
  83.     attr_t attr;
  84. }thrd_desc_t;


  87. #ifdef WIN32
  88. #define INIT_EVENT(h) { h=CreateEvent(NULL, TRUE, FALSE, NULL); }
  89. #define EXIT_EVENT(h) { if (hnull != (h)) CloseHandle(h); }
  90. #define SET_EVENT(h) { if (hnull != (h)) SetEvent(h); }
  91. #define RESET_EVENT(h) {if (hnull != (h)) ResetEvent(h); }
  92. #else
  93. #define INIT_EVENT(h) { pthread_cond_init(&(h), null); }
  94. #define EXIT_EVENT(h) { pthread_cond_destroy(&(h); }
  95. #define SET_EVENT(h) { pthread_cond_signal(&(h)); }
  96. #endif

  98. #define INIT_THRD_DESC(td) \
  99. { \
  100.     (td).h = 0; \
  101.     (td).thrd_hook = (thrd_hook_t)0; \
  102.     (td).pthrd_data = 0; \
  103.     INIT_EVENT((td).hevent_go); \
  104.     INIT_EVENT((td).hevent_exit); \
  105.     (td).list.prev=&(td).list; \
  106.     (td).list.next=&(td).list; \
  107.     (td).ref_cnts=0; \
  108. }

  110. #define CLEAR_THRD_DESC(td) \
  111. { \
  112.     (td).thrd_hook = (thrd_hook_t)0; \
  113.     (td).pthrd_data = 0; \
  114. }

  116. #define SET_HANDLER_THRD_DESC(td,h,p) \
  117. { \
  118.     (td).thrd_hook = h; \
  119.     (td).pthrd_data = p; \
  120. }

  122. typedef struct thrdpool_ops{
  123.     thrd_handle (*thrd_alloc)(thrd_hook_t thrd_hook, void* pdata);
  124.     void (*thrd_free)(thrd_handle h);

  126.     int (*wakeup)(thrd_handle h);
  127.     
  128.     int (*thrd_add)();
  129.     int (*thrd_del)(thrd_handle h);
  130.     
  131.     int (*query)();

  133.     int (*reg_notifier)(struct notifierx_block *pnb);
  134.     int (*unreg_notifier)(struct notifierx_block *pnb);    
  135. }thrdpool_ops_t;

  137. typedef struct thrdpool_s{
  138.     struct thrdpool_ops ops;
  139.     struct list_head list;
  140.     struct notifierx_head thrdpool_chain;
  141.     lock_t cslock;
  142.     attr_t attr;
  143. }thrdpool_t;

  145. extern thrdpool_t* thrdpool();

  147. extern int thrdpool_init(int nthrds);
  148. extern int thrdpool_exit();

  150. #endif


file: threadpool.c
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * @2011-11-06: initial
  5.  * @2011-11-13: add the notifier to register
  6.  */


  9. #include "threadpool.h"

  11. #ifdef WIN32

  13. #ifndef hnull
  14. #define hnull INVALID_HANDLE_VALUE
  15. #endif
  16. #ifndef null
  17. #define null NULL
  18. #endif
  19. #define __lockx(lock)            EnterCriticalSection(&(lock))
  20. #define __unlockx(lock)            LeaveCriticalSection(&(lock))
  21. #define __lockx_init(lock,attr) InitializeCriticalSection(&(lock))
  22. #define __lockx_exit(lock,attr) DeleteCriticalSection(&(lock));

  24. #else

  26. #ifndef hnull
  27. #define hnull (void*)0
  28. #endif
  29. #ifndef null
  30. #define null (void*)0
  31. #endif
  32. #define __lockx(lock)    pthread_mutex_lock(&(lock))
  33. #define __unlockx(lock) pthread_mutex_unlock(&(lock))
  34. #define __lockx_init(lock,attr) \
  35.     pthread_mutexattr_init(&(attr)); \
  36.     pthread_mutexattr_settype(&(attr),PTHREAD_MUTEX_RECURSIVE); \
  37.     pthread_mutex_init(&(lock),&(attr)); \

  39. #define __lockx_exit(attr,attr) \
  40.     pthread_mutex_destroy(&(lock)); \
  41.     pthread_mutexattr_destroy(&(attr)); \
  42.     
  43. #endif


  46. #ifdef WIN32
  47. static DWORD WINAPI thread_proc(LPVOID pvoid)
  48. #else
  49. static void *thread_proc(void *pvoid)
  50. #endif
  51. {
  52.     thrdpool_t* pthrdpool = thrdpool();
  53.     thrd_desc_t* pthrd_desc=(thrd_desc_t*)pvoid;

  55.     thrd_msg_t thrd_msg;

  57.     __assert(pthrd_desc&&pthrdpool);

  59.        INIT_THRD_MSG(thrd_msg, pthrd_desc->h);
  60.         
  61.     while (1)
  62.     {
  63. #        ifdef WIN32
  64.         if (WaitForSingleObject((HANDLE)(pthrd_desc->hevent_go), INFINITE) == WAIT_OBJECT_0)
  65. #        else
  66.         int ret=0;
  67.         __lockx(pthrd_desc->cslock);
  68.         ret = pthread_cond_wait(&pthrd_desc->hevent_go, &pthrd_desc->cslock);
  69.         __unlockx(pthrd_desc->cslock);
  70.         if (ret == 0)
  71. #        endif
  72.         {
  73.             call_chain(pthrdpool->thrdpool_chain,thrd_msg,stat_busy);
  74.             __lockx(pthrd_desc->cslock);
  75.             while(pthrd_desc->ref_cnts>0) {
  76.                 if (pthrd_desc->thrd_hook)
  77.                     pthrd_desc->thrd_hook(pthrd_desc->pthrd_data);
  78.                 pthrd_desc->ref_cnts--;
  79.             }
  80. #            ifdef WIN32
  81.                 RESET_EVENT(pthrd_desc->hevent_go);
  82. #            endif
  83.             __unlockx(pthrd_desc->cslock);

  85.         }
  86. #        ifdef WIN32
  87.         if (WaitForSingleObject(pthrd_desc->hevent_exit, 0) == WAIT_OBJECT_0)
  88.             break;
  89. #        endif
  90.         
  91.         call_chain(pthrdpool->thrdpool_chain,thrd_msg,stat_free);
  92.     } /* while(1) */
  93.     return 0;    
  94. }

  96. static thrd_handle __thrd_alloc(thrd_hook_t thrd_hook, void* pdata)
  97. {
  98.     struct list_head *list_p;
  99.     thrd_desc_t* pthrd_desc=null;
  100.     
  101.     thrdpool_t* pthrdpool = thrdpool();    
  102.     __assert(pthrdpool);
  103.     __lockx(pthrdpool->cslock);
  104.     list_for_each(list_p, &(pthrdpool->list))
  105.     {
  106.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  107.         if (!pthrd_desc->thrd_hook)
  108.         {
  109.             __lockx(pthrd_desc->cslock);
  110.             SET_HANDLER_THRD_DESC(*pthrd_desc, thrd_hook, pdata);    
  111.             __unlockx(pthrd_desc->cslock);
  112.             __unlockx(pthrdpool->cslock);
  113.             return pthrd_desc->h;
  114.         }
  115.     }
  116.     __unlockx(pthrdpool->cslock);
  117.     return 0;
  118. }

  120. static void __thrd_free(thrd_handle h)
  121. {
  122.     struct list_head *list_p;
  123.     thrd_desc_t* pthrd_desc=null;
  124.     
  125.     thrdpool_t* pthrdpool = thrdpool();    
  126.     __assert(pthrdpool);
  127.     __lockx(pthrdpool->cslock);
  128.     list_for_each(list_p, &(pthrdpool->list))
  129.     {
  130.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  131.         if (h == pthrd_desc->h) {
  132.             __lockx(pthrd_desc->cslock);
  133.             CLEAR_THRD_DESC(*pthrd_desc);    
  134.             __unlockx(pthrd_desc->cslock);
  135.         }
  136.     }    
  137.     __unlockx(pthrdpool->cslock);
  138. }
  139.     
  140. static int __wakeup(thrd_handle h)
  141. {
  142.     struct list_head *list_p;
  143.     thrd_desc_t* pthrd_desc=null;
  144.     
  145.     thrdpool_t* pthrdpool = thrdpool();    
  146.     __assert(pthrdpool);
  147.     __lockx(pthrdpool->cslock);
  148.     list_for_each(list_p, &(pthrdpool->list))
  149.     {
  150.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  151.         if (h==pthrd_desc->h)
  152.         {
  153.             __lockx(pthrd_desc->cslock);
  154.             if (hnull != pthrd_desc->hevent_go)
  155.             {
  156.                 SET_EVENT(pthrd_desc->hevent_go);
  157.                 pthrd_desc->ref_cnts++;
  158.             }
  159.             __unlockx(pthrd_desc->cslock);
  160.             __unlockx(pthrdpool->cslock);
  161.             return 0;
  162.         }
  163.     }    
  164.     __unlockx(pthrdpool->cslock);
  165.     return -1;
  166. }
  167.     
  168. static int __thrd_add()
  169. {
  170.     thrdpool_t* pthrdpool = thrdpool();
  171.     thrd_desc_t* pthrd_desc=null;
  172.     __assert(pthrdpool);

  174.     pthrd_desc=(thrd_desc_t*)malloc(sizeof(thrd_desc_t));
  175.     __assert(pthrd_desc);
  176.     
  177.     INIT_THRD_DESC(*pthrd_desc);

  179.     __lockx_init(pthrd_desc->cslock,pthrd_desc->attr);

  181. #    ifdef WIN32    
  182.     pthrd_desc->h = CreateThread(
  183.         null, // default security attributes
  184.         0, // use default stack size
  185.         thread_proc,// thread function
  186.         pthrd_desc, // argument to thread function
  187.         0, // use default creation flags
  188.         0);
  189.     if(NULL == pthrd_desc->h)
  190.         goto __err;
  191. #    else
  192.     if(pthread_create(&pthrd_desc->h, null, thread_proc, null)!=0)
  193.         goto __err;
  194. #    endif
  195.     
  196.     __lockx(pthrdpool->cslock);
  197.     list_add(&pthrd_desc->list, &pthrdpool->list);
  198.     __unlockx(pthrdpool->cslock);
  199.     return 0;

  201. __err:
  202.     __lockx_exit(pthrd_desc->cslock, pthrd_desc->attr);
  203.     free(pthrd_desc);

  205.     return -1;
  206. }

  208. static int __thrd_del(thrd_handle h)
  209. {
  210.     struct list_head *list_p;
  211.     thrd_desc_t* pthrd_desc=null;
  212.     

  214.     thrdpool_t* pthrdpool = thrdpool();    
  215.     __assert(pthrdpool);
  216.     __lockx(pthrdpool->cslock);
  217.     list_for_each(list_p, &(pthrdpool->list))
  218.     {
  219.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  220.         if (h==pthrd_desc->h) {
  221.             
  222. #            ifdef WIN32
  223.             SET_EVENT(pthrd_desc->hevent_exit);
  224.             SET_EVENT(pthrd_desc->hevent_go);
  225. #            else
  226.             SET_EVENT(pthrd_desc->hevent_go);
  227.             sleep(1);
  228.             pthread_cancel(pthrd_desc->h);
  229. #            endif
  230.             
  231.             /* wait the thread exit */
  232.             if (hnull != pthrd_desc->h)
  233.             {
  234. #                ifdef WIN32
  235.                 /* terminal the log server thread until 1 second over */
  236.                 unsigned long state = WaitForSingleObject (pthrd_desc->h, 2000);
  237.                 switch (state)
  238.                 {
  239.                 case WAIT_TIMEOUT:
  240.                     {
  241.                         unsigned long exit_code = 0;
  242.                         if (0 != TerminateThread(pthrd_desc->h, exit_code))
  243.                             ; /* terminate the server thread */
  244.                         else
  245.                             ; /* terminate the LogSrv thread failed */
  246.                         break;
  247.                     }
  248.                 case WAIT_ABANDONED: break; /* the Thread abandoned */
  249.                 case WAIT_OBJECT_0: break; /* exit the server thread */
  250.                 default: break;
  251.                 }
  252.                 CloseHandle(pthrd_desc->h);
  253. #                else
  254.                 int state = pthread_join(pthrd_desc->h, null);
  255. #                endif
  256.                 pthrd_desc->h=hnull;
  257.             }

  259.             __lockx_exit(pthrd_desc->cslock,pthrd_desc->attr);

  261. #            ifdef WIN32
  262.             EXIT_EVENT(pthrd_desc->hevent_exit);
  263. #            endif

  265.             EXIT_EVENT(pthrd_desc->hevent_go);

  267.             /* remove itself from the list */
  268.             list_del(&pthrd_desc->list);
  269.             /* free the memory from the malloc of the thread descript struct */
  270.             free(pthrd_desc);
  271.             
  272.             break;
  273.         } // if (h==pthrd_desc->h)
  274.     }    
  275.     __unlockx(pthrdpool->cslock);
  276.     return 0;
  277. }

  279. static void __display(const thrd_desc_t* pthrd_desc)
  280. {
  281.     __assert(pthrd_desc);
  282.     printf("handle:%08x, hook: %s\n",
  283.         pthrd_desc->h, pthrd_desc->thrd_hook ? "installed":"uninstalled");
  284. }
  285.     
  286. static int __query()
  287. {
  288.     struct list_head *list_p;
  289.     thrd_desc_t* pthrd_desc=null;
  290.     
  291.     thrdpool_t* pthrdpool = thrdpool();    
  292.     __assert(pthrdpool);
  293.     __lockx(pthrdpool->cslock);
  294.     list_for_each(list_p, &(pthrdpool->list))
  295.     {
  296.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  297.         __display(pthrd_desc);
  298.     }    
  299.     printf("------------------------------\n");
  300.     __unlockx(pthrdpool->cslock);
  301.     return 0;
  302. }

  304. static int __reg_notifier(struct notifierx_block *pnb)
  305. {
  306.     thrdpool_t* pthrdpool = thrdpool();    
  307.     __assert(pthrdpool&&pnb);
  308.     return notifierx_chain_register(&pthrdpool->thrdpool_chain, pnb);
  309. }

  311. static int __unreg_notifier(struct notifierx_block *pnb)
  312. {
  313.     thrdpool_t* pthrdpool = thrdpool();    
  314.     __assert(pnb);
  315.     return notifierx_chain_unregister(&pthrdpool->thrdpool_chain, pnb);
  316. }

  318. thrdpool_t* thrdpool()
  319. {
  320.     static thrdpool_t s_thrdpool;
  321.     return &s_thrdpool;
  322. }

  324. int thrdpool_init(int nthrds)
  325. {
  326.     thrdpool_t* pthrdpool = thrdpool();
  327.     int ret=0, count=0;
  328.     __assert(pthrdpool);

  330.     INIT_NOTIFIERX_HEAD(pthrdpool->thrdpool_chain);
  331.     __lockx_init(pthrdpool->cslock,pthrdpool->attr);

  333.     pthrdpool->list.next=&pthrdpool->list;
  334.     pthrdpool->list.prev=&pthrdpool->list;

  336.     pthrdpool->ops.thrd_alloc    =__thrd_alloc;
  337.     pthrdpool->ops.thrd_free    =__thrd_free;
  338.     pthrdpool->ops.wakeup    =__wakeup;
  339.     pthrdpool->ops.thrd_add =__thrd_add;
  340.     pthrdpool->ops.thrd_del    =__thrd_del;
  341.     pthrdpool->ops.query    =__query;
  342.     pthrdpool->ops.reg_notifier = __reg_notifier;
  343.     pthrdpool->ops.unreg_notifier = __unreg_notifier;

  345.     while (count<nthrds) {
  346.         ret=__thrd_add();
  347.         __assert(-1!=ret);
  348.         count++;
  349.     }
  350.     return 0;
  351. }

  353. int thrdpool_exit()
  354. {
  355.     struct list_head *list_p;
  356.     thrd_desc_t* pthrd_desc=null;
  357.     thrd_desc_t* pthrd_temp=null;
  358.     thrdpool_t* pthrdpool = thrdpool();    
  359.     __assert(pthrdpool);

  361.     list_for_each_safe(list_p, pthrd_temp, &(pthrdpool->list))
  362.     {
  363.         pthrd_desc = list_entry(list_p, thrd_desc_t, list);
  364.         if (hnull!=pthrd_desc->h)
  365.             __thrd_del(pthrd_desc->h);
  366.     }
  367.     __lockx_exit(pthrdpool->cslock,pthrdpool->attr);
  368.     EXIT_NOTIFIERX_HEAD(pthrdpool->thrdpool_chain);

  370.     return 0;
  371. }

file: notifierx.h
  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-11-13
  5.  */

  7. #ifndef _NOTIFIERX_H_
  8. #define _NOTIFIERX_H_

  10. #include "list.h"

  12. #ifdef WIN32
  13. # include "windows.h"
  14. #else
  15. # include <pthread.h>
  16. #endif

  18. #define null (void*)0
  19. #define NULL (void*)0

  21. #ifndef __assert
  22. #define __assert(x)
  23. #endif

  25. #ifdef WIN32
  26. #    define thrd_handle    HANDLE
  27. #    define event_t        HANDLE
  28. #    define lock_t        CRITICAL_SECTION
  29. #    define attr_t        void*
  30. #else
  31. #    define thrd_handle    pthread_t
  32. #    define event_t        pthread_cond_t
  33. #    define lock_t        pthread_mutex_t
  34. #    define attr_t        pthread_mutexattr_t
  35. #endif


  38. typedef struct notifierx_block {
  39.     int (*notifierx_call)(struct notifierx_block *pnb, unsigned long nlen, const void *pdata);
  40.     struct list_head list;
  41. }notifierx_block_t;

  43. struct notifierx_head {
  44.     lock_t cslock;
  45.     attr_t attr;
  46.     struct list_head head;
  47. };

  49. #define INIT_NOTIFIERX_HEAD(name) do {                \
  50.         __lockx_init((name).cslock,(name).attr);    \
  51.         INIT_LIST_HEAD(&(name).head);                \
  52.     } while (0)
  53.         

  55. #define EXIT_NOTIFIERX_HEAD(name) do {                    \
  56.         notifierx_chain_all_unregister(&(name));    \
  57.         __lockx_exit((name).cslock, (name).attr);        \
  58.     } while (0)
  59. //            

  61. extern int notifierx_chain_register(struct notifierx_head *pnh, struct notifierx_block *pnb);
  62. extern int notifierx_chain_all_unregister(struct notifierx_head *pnh);
  63. extern int notifierx_chain_unregister(struct notifierx_head *pnh, struct notifierx_block *pnb);
  64. extern int notifierx_call_chain(struct notifierx_head *pnh, unsigned long nlen, void *pdata);

  66. #endif



file: notifierx.c

  1. /**
  2.  * author: vincent.cws2008@gmail.com
  3.  * history:
  4.  * initial @ 2011-11-13
  5.  */


  8. #include "notifierx.h"

  10. #ifdef WIN32

  12. #ifndef hnull
  13. #define hnull INVALID_HANDLE_VALUE
  14. #endif
  15. #ifndef null
  16. #define null NULL
  17. #endif
  18. #define __lockx(lock)            EnterCriticalSection(&(lock))
  19. #define __unlockx(lock)            LeaveCriticalSection(&(lock))
  20. #define __lockx_init(lock,attr) InitializeCriticalSection(&(lock))
  21. #define __lockx_exit(lock,attr) DeleteCriticalSection(&(lock))

  23. #else

  25. #ifndef hnull
  26. #define hnull (void*)0
  27. #endif
  28. #ifndef null
  29. #define null (void*)0
  30. #endif
  31. #define __lockx(lock)    pthread_mutex_lock(&(lock))
  32. #define __unlockx(lock) pthread_mutex_unlock(&(lock))
  33. #define __lockx_init(lock,attr) \
  34.     pthread_mutexattr_init(&(attr)); \
  35.     pthread_mutexattr_settype(&(attr),PTHREAD_MUTEX_RECURSIVE); \
  36.     pthread_mutex_init(&(lock),&(attr)); \

  38. #define __lockx_exit(attr,attr) \
  39.     pthread_mutex_destroy(&(lock)); \
  40.     pthread_mutexattr_destroy(&(attr)); \
  41.     
  42. #endif


  45. int notifierx_chain_register(struct notifierx_head *pnh,
  46.         struct notifierx_block *pnb)
  47. {
  48.     __assert(pnh&&pnb);
  49.     __lockx(pnh->cslock);
  50.     list_add(&pnb->list, &pnh->head);
  51.     __unlockx(pnh->cslock);    
  52.     return 0;
  53. }

  55. int notifierx_chain_all_unregister(struct notifierx_head *pnh)
  56. {
  57.     struct list_head *list_p;
  58.     notifierx_block_t* pnb_it=null;
  59.     notifierx_block_t* pnb_temp=null;
  60.     __assert(pnh);

  62.     __lockx(pnh->cslock);
  63.     list_for_each_safe(list_p, pnb_temp, &(pnh->head))
  64.     {
  65.         pnb_it = list_entry(list_p, notifierx_block_t, list);
  66.         list_del(&pnb_it->list);
  67.     }
  68.     
  69.     __unlockx(pnh->cslock);

  71.     return 0;
  72. }

  74. int notifierx_chain_unregister(struct notifierx_head *pnh,
  75.         struct notifierx_block *pnb)
  76. {
  77.     struct list_head *list_p;
  78.     struct notifierx_block *pnb_it;
  79.     __assert(pnh&&pnb);
  80.     
  81.     __lockx(pnh->cslock);
  82.     list_for_each(list_p, &(pnh->head))
  83.     {
  84.         pnb_it = list_entry(list_p, notifierx_block_t, list);
  85.         if (pnb_it->notifierx_call == pnb->notifierx_call)
  86.         {
  87.             list_del(&pnb_it->list);
  88.             __unlockx(pnh->cslock);
  89.             return 0;
  90.         }
  91.     }
  92.     __unlockx(pnh->cslock);    
  93.     return -1;
  94. }

  96. int notifierx_call_chain(struct notifierx_head *pnh, unsigned long nlen, void *pdata)
  97. {
  98.     struct list_head *list_p;
  99.     notifierx_block_t* pnb_it=null;

  101.     __assert(pnh);
  102.     
  103.     __lockx(pnh->cslock);
  104.     list_for_each(list_p, &(pnh->head))
  105.     {
  106.         pnb_it = list_entry(list_p, notifierx_block_t, list);
  107.         pnb_it->notifierx_call(pnb_it, nlen, pdata);
  108.     }    
  109.     __unlockx(pnh->cslock);

  111.     return 0;
  112. }



attached:

 threadpool.rar  


阅读(3182) | 评论(0) | 转发(5) |
0

上一篇：OLED调试记录

下一篇：工作队列实现

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

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

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

16024965号-6