在Linux下写一个线程池以及线程池的一些用法和注意点 – Mereyct

–>线程池介绍(大部分来自网络)

   在这个部分,详细的介绍一下线程池的作用以及它的技术背景以及他提供的一些服务等。大部分内容来自我日常生活中在网络中学习到的一些概念性的东西。

–>代码(大约240行)

   测试一下,具体的实现。

–>代码下载

————————————————————————————————————————————–

–>线程池介绍

1、技术背景:服务器程序利用线程技术响应客户请求已经司空见惯,但是线程的使用是有待优化和处理的。单线程执行并不是一个高效的方式,这个时候可能就要考虑高并发,多线程等方式。线程池也是线程优化的一种方式。

在面向对象的过程中,对象的创建和销毁是非常占资源的,每创建一个对象都要获取内存资源以及其他一些资源。在Java中更是如此,他要跟踪每一个对象,在它使用完毕的时候,自动的销毁它并垃圾回收。可想而知,运行的速度之慢。这就产生了“池化技术”。

2、线程池如何提高服务器程序的性能?

     ●T1 = 创建线程

   ●T2 = 执行线程 包括访问共享数据、线程同步等

   ●T3 = 销毁线程

   ●T = T1 + T2 + T3   

  单线程的情况下,系统花大量的时间再T1、T3阶段。我们要采取最优的措施,减少T1和T3的系统开销。线程池不仅调整T1,T3产生的时间段,而且它还显著减少了创建线程的数目。

假设:一台服务器,每天要处理10万个请求,这时候,我们比较不用线程池的技术和用线程池,他们的区别。
如果没有用线程池的话,那么程序将会用大把的时候来创建这10万个线程,用线程池,我们一般可用的线程数不会大于10万,所以可以大大减小开销。

3、具体工作流程

    线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中。如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队,但他们要等到其他线程完成后才启动。

4、何时不使用线程池线程  

    ● 如果需要使一个任务具有特定优先级

    ● 如果具有可能会长时间运行(并因此阻塞其他任务)的任务

    ● 如果需要将线程放置到单线程单元中(线程池中的线程均处于多线程单元中)

    ● 如果需要永久标识来标识和控制线程,比如想使用专用线程来终止该线程,将其挂起或按名称发现它

5、一般使用线程池的程序的特点

    ● 需要花费大量的时候,并且请求的时间比较短。

    ● 对性能要求苛刻的应用,比如要求服务器迅速响应客户请求。

    ● 接受突发性的大量请求,但不至于使服务器因此产生大量线程的应用

 

–>代码

     为了方便贴出代码,我全部放在一个文件里。运行gcc main.c -o main -lpthread -lrt运行  

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <string.h>
5 #include <errno.h>
6 #include <time.h>
7 #include <pthread.h>
8
9 typedef struct condition
10 {
11 pthread_mutex_t pmutex;
12 pthread_cond_t pcond;
13 }condition_t;
14
15 typedef struct task
16 {
17 void *(*run)(void *arg);
18 void *arg;
19 struct task *next;
20 }task_t;
21
22 typedef struct threadpool
23 {
24 condition_t ready;
25 task_t *first;
26 task_t *last;
27 int counter;
28 int idle;
29 int max_threads;
30 int quit;
31 }threadpool_t;
32
33
34 int condition_init(condition_t *cond)
35 {
36 int status;
37 if((status = pthread_mutex_init(&cond->pmutex,NULL)))//返回0代表初始化成功
38 return status;
39 if((status = pthread_cond_init(&cond->pcond,NULL)))
40 return status;
41 return 0;
42 }
43 int condition_lock(condition_t *cond)
44 {
45 return pthread_mutex_lock(&cond -> pmutex);
46 }
47 int condition_unlock(condition_t *cond)
48 {
49 return pthread_mutex_unlock(&cond -> pmutex);
50 }
51 int condition_wait(condition_t *cond)
52 {
53 return pthread_cond_wait(&cond -> pcond,&cond -> pmutex);
54 }
55 int condition_timewait(condition_t *cond,const struct timespec *abstime)
56 {
57 return pthread_cond_timedwait(&cond->pcond,&cond->pmutex,abstime);
58 }
59 int condition_signal(condition_t *cond)
60 {
61 return pthread_cond_signal(&cond->pcond);
62 }
63 int condition_broadcast(condition_t *cond)
64 {
65 return pthread_cond_broadcast(&cond -> pcond);
66 }
67 int condition_destory(condition_t *cond)
68 {
69 int status;
70 if((status = pthread_mutex_destroy(&cond -> pmutex)))
71 return status;
72 if((status = pthread_cond_destroy(&cond -> pcond)))
73 return status;
74 return 0;
75 }
76
77
78 void *thread_routine(void *arg)
79 {
80 struct timespec abstime;
81 int timeout;
82 printf(thread 0x%0x is startingn,(int)pthread_self());
83 threadpool_t *pool = (threadpool_t *)arg;
84 while(1)
85 {
86 timeout = 0;
87 condition_lock(&pool -> ready);
88 pool -> idle++;
89 //等待队列有任务到来或者线程池销毁的通知
90 while(pool -> first == NULL && !pool -> quit)
91 {
92 printf(thread 0x%0x is waitingn,(int)pthread_self());
93 clock_gettime(CLOCK_REALTIME,&abstime);
94 abstime.tv_sec += 2;
95 int status=condition_timewait(&pool -> ready,&abstime);
96 if(status == ETIMEDOUT)
97 {
98 printf(thread 0x%0x is wait timed outn,(int)pthread_self());
99 timeout = 1;
100 break;
101 }
102
103 }
104 //等到到条件,处于工作状态
105 pool -> idle–;
106
107 if(pool -> first != NULL)
108 {
109 task_t *t = pool -> first;
110 pool -> first = t -> next;
111 //需要先解锁,以便添加新任务。其他消费者线程能够进入等待任务。
112 condition_unlock(&pool -> ready);
113 t -> run(t->arg);
114 free(t);
115 condition_lock(&pool -> ready);
116 }
117 //等待线程池销毁的通知
118 if(pool -> quit && pool ->first == NULL)
119 {
120 pool -> counter–;
121 if(pool->counter == 0)
122 {
123 condition_signal(&pool -> ready);
124 }
125 condition_unlock(&pool->ready);
126 //跳出循环之前要记得解锁
127 break;
128 }
129
130 if(timeout &&pool -> first ==NULL)
131 {
132 pool -> counter–;
133 condition_unlock(&pool->ready);
134 //跳出循环之前要记得解锁
135 break;
136 }
137 condition_unlock(&pool -> ready);
138 }
139
140 printf(thread 0x%0x is exitingn,(int)pthread_self());
141 return NULL;
142 }
143
144 //初始化
145 void threadpool_init(threadpool_t *pool, int threads)
146 {
147 condition_init(&pool -> ready);
148 pool -> first = NULL;
149 pool -> last = NULL;
150 pool -> counter = 0;
151 pool -> idle = 0;
152 pool -> max_threads = threads;
153 pool -> quit = 0;
154 }
155
156 //加任务
157 void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg),void *arg)
158 {
159 task_t *newstask = (task_t *)malloc(sizeof(task_t));
160 newstask->run = run;
161 newstask->arg = arg;
162 newstask -> next = NULL;
163
164 condition_lock(&pool -> ready);
165 //将任务添加到对列中
166 if(pool -> first ==NULL)
167 {
168 pool -> first = newstask;
169 }
170 else
171 pool -> last -> next = newstask;
172 pool -> last = newstask;
173 //如果有等待线程,则唤醒其中一个
174 if(pool -> idle > 0)
175 {
176 condition_signal(&pool -> ready);
177 }
178 else if(pool -> counter < pool -> max_threads)
179 {
180 pthread_t tid;
181 pthread_create(&tid,NULL,thread_routine,pool);
182 pool -> counter++;
183 }
184 condition_unlock(&pool -> ready);
185 }
186 //销毁线程池
187 void threadpool_destory(threadpool_t *pool)
188 {
189
190 if(pool -> quit)
191 {
192 return;
193 }
194 condition_lock(&pool -> ready);
195 pool->quit = 1;
196 if(pool -> counter > 0)
197 {
198 if(pool -> idle > 0)
199 condition_broadcast(&pool->ready);
200
201 while(pool -> counter > 0)
202 {
203 condition_wait(&pool->ready);
204 }
205 }
206 condition_unlock(&pool->ready);
207 condition_destory(&pool -> ready);
208 }
209
210
211 void *mytask(void *arg)
212 {
213 printf(thread 0x%0x is working on task %dn,(int)pthread_self(),*(int*)arg);
214 sleep(1);
215 free(arg);
216 return NULL;
217 }
218 int main()
219 {
220 threadpool_t pool;
221 threadpool_init(&pool,3);
222
223 int i ;
224 for(i = 0; i < 10; i++)
225 {
226 int *arg = (int *)malloc(sizeof(int));
227 *arg = i;
228 threadpool_add_task(&pool,mytask,arg);
229 }
230
231 sleep(15);//为了等待其他线程结束 当然也可以通过pthread_join来做
232 threadpool_destory(&pool);
233 return 0;
234 }

 

–>代码下载

    Github

————————————————————————————————————————————–

本文是我学习后,一些总结。比较基础,适合新接触Linux编程的人学习。请勿转载。

本文链接:在Linux下写一个线程池以及线程池的一些用法和注意点,转载请注明。



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量