c语言多线程实现三人过河,C语言实现简单线程池（转-Newerth）

1: #include

2: #include

3: #include

4: #include

5: #include

6:

7: #include "tpool.h"

8:

9: static tpool_t *tpool = NULL;

10:

11: /* 工作者线程函数, 从任务链表中取出任务并执行 */

12: static void*

13: thread_routine(void *arg)

14: {

15: tpool_work_t *work;

16:

17: while(1) {

18: /* 如果线程池没有被销毁且没有任务要执行，则等待 */

19: pthread_mutex_lock(&tpool->queue_lock);

20: while(!tpool->queue_head && !tpool->shutdown) {

21: pthread_cond_wait(&tpool->queue_ready, &tpool->queue_lock);

22: }

23: if (tpool->shutdown) {

24: pthread_mutex_unlock(&tpool->queue_lock);

25: pthread_exit(NULL);

26: }

27: work = tpool->queue_head;

28: tpool->queue_head = tpool->queue_head->next;

29: pthread_mutex_unlock(&tpool->queue_lock);

30:

31: work->routine(work->arg);

32: free(work);

33: }

34:

35: return NULL;

36: }

37:

38: /*

39: * 创建线程池

40: */

41: int

42: tpool_create(int max_thr_num)

43: {

44: int i;

45:

46: tpool = calloc(1, sizeof(tpool_t));

47: if (!tpool) {

48: printf("%s: calloc failed\n", __FUNCTION__);

49: exit(1);

50: }

51:

52: /* 初始化 */

53: tpool->max_thr_num = max_thr_num;

54: tpool->shutdown = 0;

55: tpool->queue_head = NULL;

56: if (pthread_mutex_init(&tpool->queue_lock, NULL) !=0) {

57: printf("%s: pthread_mutex_init failed, errno:%d, error:%s\n",

58: __FUNCTION__, errno, strerror(errno));

59: exit(1);

60: }

61: if (pthread_cond_init(&tpool->queue_ready, NULL) !=0 ) {

62: printf("%s: pthread_cond_init failed, errno:%d, error:%s\n",

63: __FUNCTION__, errno, strerror(errno));

64: exit(1);

65: }

66:

67: /* 创建工作者线程 */

68: tpool->thr_id = calloc(max_thr_num, sizeof(pthread_t));

69: if (!tpool->thr_id) {

70: printf("%s: calloc failed\n", __FUNCTION__);

71: exit(1);

72: }

73: for (i = 0; i < max_thr_num; ++i) {

74: if (pthread_create(&tpool->thr_id[i], NULL, thread_routine, NULL) != 0){

75: printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__,

76: errno, strerror(errno));

77: exit(1);

78: }

79:

80: }

81:

82: return 0;

83: }

84:

85: /* 销毁线程池 */

86: void

87: tpool_destroy()

88: {

89: int i;

90: tpool_work_t *member;

91:

92: if (tpool->shutdown) {

93: return;

94: }

95: tpool->shutdown = 1;

96:

97: /* 通知所有正在等待的线程 */

98: pthread_mutex_lock(&tpool->queue_lock);

99: pthread_cond_broadcast(&tpool->queue_ready);

100: pthread_mutex_unlock(&tpool->queue_lock);

101: for (i = 0; i < tpool->max_thr_num; ++i) {

102: pthread_join(tpool->thr_id[i], NULL);

103: }

104: free(tpool->thr_id);

105:

106: while(tpool->queue_head) {

107: member = tpool->queue_head;

108: tpool->queue_head = tpool->queue_head->next;

109: free(member);

110: }

111:

112: pthread_mutex_destroy(&tpool->queue_lock);

113: pthread_cond_destroy(&tpool->queue_ready);

114:

115: free(tpool);

116: }

117:

118: /* 向线程池添加任务 */

119: int

120: tpool_add_work(void*(*routine)(void*), void *arg)

121: {

122: tpool_work_t *work, *member;

123:

124: if (!routine){

125: printf("%s:Invalid argument\n", __FUNCTION__);

126: return -1;

127: }

128:

129: work = malloc(sizeof(tpool_work_t));

130: if (!work) {

131: printf("%s:malloc failed\n", __FUNCTION__);

132: return -1;

133: }

134: work->routine = routine;

135: work->arg = arg;

136: work->next = NULL;

137:

138: pthread_mutex_lock(&tpool->queue_lock);

139: member = tpool->queue_head;

140: if (!member) {

141: tpool->queue_head = work;

142: } else {

143: while(member->next) {

144: member = member->next;

145: }

146: member->next = work;

147: }

148: /* 通知工作者线程，有新任务添加 */

149: pthread_cond_signal(&tpool->queue_ready);

150: pthread_mutex_unlock(&tpool->queue_lock);

151:

152: return 0;

153: }

154:

155: