上节实现了一条最简单的线程等待工作队列。
http://blog.csdn.net/morixinguan/article/details/77758206
但设计还有诸多因素需要考虑和改进，例如以下：
void print(queue_list *header)
{
int count = 0 ;
while(1)
{
sleep(1);
printf("工作队列 work_serial_num: %d hello kitty.....!\n",header->work_queue.work_serial_num);
count++ ;
if(count == 10)
break ;
}
}在上面一篇文章的代码中，其中一个工作任务出现了sleep的延迟操作，那么一旦工作任务一多，是不是每个工作队列都需要去调用一个sleep函数？那显得很浪费。。。
我们不如在工作结构体中嵌套两个元素，分别是工作延迟的时间设定，以及最终调用延迟func实现延迟，就像设计等待倒计时一样，时间一到，就出队。这个结构体改进如下：
//工作者结构体
typedef struct __work_st
{
//工作者编号
int work_serial_num;
//延迟的时间，以s来计算
int sec ;
//工作产生的时间延迟(使用sleep函数产生)
void (*work_sleep)();
//工作者执行操作
void (*queue_st)();
}work_st ; 这样，在外头实现对sleep函数的封装，可以实现如下：
//每一个工作所对应的时间
void work_sleep(queue_list *header)
{
printf("工作线程等待%ds后执行\n",header->work_queue.sec);
sleep(header->work_queue.sec);
}sec和work_sleep在入队时对当前的节点进行初始化，如果有多个工作任务插入，则往后指向下一个节点，依次类推。这样出队的时候就调用初始化好的每个节点对应的数据，执行等待，后面再执行对应的任务。
在出队的时候设计原来是这样的结构：
while(NULL != p->next)
{
p = p->next ;
}这样在出队的时候就会将入队的所有数据全部出队，这样做不是不对。但如果考虑一个问题，要是一次只出一个，那这个接口就不符合设计要求了。所以，我们改进这个接口，让它调用一次的时候，通过判断队列头来出队，一次只出队一个任务，而不是全部出队，当然也可以全部出队，取决于程序逻辑的实现。
改进接口如下：
//逐个出队
//出队
queue_list *De_queue(queue_list *header)
{
int ret ;
int count = 0;
int queue_length = 0;
pthread_t tid ;
queue_list *p = header ;
queue_list *prev = NULL ;
//如果当前节点的下一个节点为空，则返回空
if(header->next == NULL){
free(header);
header = NULL ;
printf("header mem:0x%p\n",header);
return header ;
}
prev = p ;
p = p->next ;
ret = pthread_create(&tid, NULL , (void *)p->work_queue.work_sleep, p);
if(ret < 0){
printf("create work_thread fair!ssssssssssssssssssssssssss\n");
return ;
}
//等待对应的工作结束
pthread_join(tid,NULL);
//每出队一次，就相当于创建一条线程来执行对应的工作
ret = pthread_create(&tid, NULL , (void *)p->work_queue.queue_st, p);
if(ret < 0){
printf("create work_thread fair!ssssssssssssssssssssssssss\n");
return ;
}
//等待对应的工作结束
pthread_join(tid,NULL);
//获取队列的长度
queue_length = Get_queue_Length(header);
queue_length = queue_length - 1;
header->queue_length = queue_length ;
printf("当前队列的长度:%d %d\n",queue_length,header->queue_length);
prev->next = p->next ;
free(p);
return prev ;
}
这里设计还要重视一个比较关键的问题，这也是所有初学者不会考虑到的问题，就是内存的分配和释放的问题。
如上程序，如果free(header)后不将header指向NULL，那么header此时是个野指针。那么返回后，在主程序中判断header的时候，它一定不为空。这种问题，想必大学老师在讲课的时候几乎都没有去讲过，所以很多人一直被误导，malloc到的内存,free掉以后指针就为空了，是这样吗？我们可以写个程序测测看：
#include <stdio.h>
#include <stdlib.h>
#define SIZE 10
int main(void)
{
int *p = NULL ;
p = malloc(SIZE) ;
*p = 100 ;
printf("malloc size: %d malloc mem:0x%p %d\n",SIZE,p,*p);
free(p);
printf("malloc size: %d malloc mem:0x%p\n",SIZE,p);
//p = NULL ;
printf("malloc size: %d malloc mem:0x%p %d\n",SIZE,p,*p);
return 0 ;
}运行结果：
看到了吧，mallco后，对p指针简引用赋值，得到的是100，而free后，虽然释放了内存，但简引用指针p的时候却是个随机值，此时它已经成为了一个野指针。
如果我们把p = NULL加上呢？什么样的结果：
运行结果：
很明显，对一个p = NULL的指针简引用，它一定会段错误。
扯多了，接下来看看等待工作队列的改进整体的实现：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<pthread.h>
#include <Windows.h>
#define QUEUE_LEN 10
//工作者队列实现
typedef struct __work_st
{
//工作者编号
int work_serial_num;
//延迟的时间，以s来计算
int sec ;
//工作产生的时间延迟(使用sleep函数产生)
void (*work_sleep)();
//工作者执行操作
void (*queue_st)();
}work_st ;
//队列结构体实现
typedef struct queue_st
{
work_st work_queue ;
//队列的最大长度
int queue_max_length ;
//队列的实际长度
int queue_length ;
//队列是否为空的标志
int Null_flag ;
//队列是否为满的标志
int Full_flag ;
//指向下一个队列节点
struct queue_st *next ;
}queue_list;
//初始化队列头---->虚设，没有意义，只是为了方便操作
void Init_queue_header(queue_list *header , int queue_length) ;
//检查当前队列是否已经满了 ，通过队列满标志和队列最大长度这两个条件同时成立来判断
int Check_queue_full(queue_list *header , int queue_length);
//入队--->将要执行的编号和功能函数注册到队列中去
int En_queue(queue_list *header , work_st *workArray) ;
//出队--->每个编号对应的功能函数会对应创建一条线程，等待第一条工作队列结束后，才会执行接下来的
//工作。
queue_list *De_queue(queue_list *header) ;
//检查当前的队列是否为空，检查的标准是不包括队列头，通过引用计数来计算队列的长度
int Check_queue_null(queue_list *header) ;
//获取当前队列的长度，不包括队列头
int Get_queue_Length(queue_list *header) ;
//每一个工作所对应的时间
void work_sleep(queue_list *header);
void print(queue_list *header)
{
int count = 0 ;
while(1)
{
printf("工作队列 work_serial_num: %d hello kitty.....!\n",header->work_queue.work_serial_num);
count++ ;
if(count == 2)
break ;
}
}
void print1(queue_list *header)
{
int count = 0 ;
while(1)
{
printf("工作队列 work_serial_num: %d hello world.....!\n",header->work_queue.work_serial_num);
count++ ;
if(count == 3)
break ;
}
}
//执行工作队列里的任务,每个任务都是一条线程
work_st work_array[] =
{
{1,1,work_sleep,print},
{2,2,work_sleep,print1},
{3,3,work_sleep,print1},
};
int main(void)
{
int ret = 0 ;
queue_list *queue_node = NULL ;
queue_node = malloc(sizeof(queue_list));
//检查队列是否为空队列
if(queue_node == NULL)
{
printf("队列申请内存为失败!\n");
return -1 ;
}
printf("queue_node mem:0x%p\n",queue_node);
//初始化工作队列头
Init_queue_header(queue_node,3);//QUEUE_LEN
//入队
printf("入队:\n");
int i ;
for(i = 0 ; i < 3 ; i++)
{
En_queue(queue_node , &work_array[i]);
}
//获取当前队列的长度
printf("入队后:\n");
ret = Get_queue_Length(queue_node);
printf("当前队列的长度:%d\n",ret);
printf("----------------------------------------------------------------\n");
while(queue_node)
queue_node = De_queue(queue_node);
if(queue_node == NULL)
printf("节点是空的\n");
else
printf("节点不为空!\n");
return 0 ;
}
//每一个工作所对应的时间
void work_sleep(queue_list *header)
{
printf("工作线程等待%ds后执行\n",header->work_queue.sec);
sleep(header->work_queue.sec);
}
//初始化队列头节点
void Init_queue_header(queue_list *header , int queue_max_length)
{
queue_list *p = header ;
p->work_queue.work_serial_num = 0 ;
p->work_queue.queue_st = NULL ;
p->queue_length = 0 ;
p->queue_max_length = queue_max_length ;
//默认初始化队列的时候，保存的NULL_flag是生效的
p->Null_flag = 1 ;
//默认是不生效的
p->Full_flag = 0 ;
p->next = NULL ;
}
//检查队列是否为空
//return 1 为空
//return !1 不为空
int Check_queue_null(queue_list *header)
{
queue_list *p = header ;
if(NULL == p)
return 1 ;
if(p->Null_flag)
{
p->Null_flag = 1;
return p->Null_flag ;
}
p->Null_flag = 0 ;
return p->Full_flag ;
}
//检查队列是否已经满了
// : 1 为满
int Check_queue_full(queue_list *header , int queue_length)
{
queue_list *p = header ;
if(queue_length == p->Full_flag && queue_length == p->queue_max_length)
return 1 ;
}
//获取当前队列的长度
int Get_queue_Length(queue_list *header)
{
queue_list *p = header ;
if(NULL == p)
return -1 ;
return p->queue_length ;
}
//入队
int En_queue(queue_list *header , work_st *workArray)
{
queue_list *p = header ;
queue_list *New = NULL ;
New = malloc(sizeof(queue_list));
if(NULL == New){
fprintf(stderr , "分配失败!\n");
return ;
}
memset(New,0,sizeof(queue_list));
p->queue_length++ ;
if(p->queue_length > p->queue_max_length){
printf("队列已满!不能再插入数据\n");
p->Full_flag = 1 ;
p->queue_length-- ;
return -1;
}
New->work_queue.work_serial_num = workArray->work_serial_num ;
printf("sec :%d\n",workArray->sec);
New->work_queue.sec = workArray->sec ;
New->work_queue.work_sleep = workArray->work_sleep ;
New->work_queue.queue_st = workArray->queue_st ;
p->Full_flag = 0 ;
p->Null_flag = 0 ;
while(NULL != p->next)
p = p->next ;
New->next = p->next ;
p->next = New ;
}
//逐个出队
//出队
queue_list *De_queue(queue_list *header)
{
int ret ;
int count = 0;
int queue_length = 0;
pthread_t tid ;
queue_list *p = header ;
queue_list *prev = NULL ;
//如果当前节点的下一个节点为空，则返回空
if(header->next == NULL){
free(header);
header = NULL ;
printf("header mem:0x%p\n",header);
return header ;
}
prev = p ;
p = p->next ;
ret = pthread_create(&tid, NULL , (void *)p->work_queue.work_sleep, p);
if(ret < 0){
printf("create work_thread fair!ssssssssssssssssssssssssss\n");
return ;
}
//等待对应的工作结束
pthread_join(tid,NULL);
//每出队一次，就相当于创建一条线程来执行对应的工作
ret = pthread_create(&tid, NULL , (void *)p->work_queue.queue_st, p);
if(ret < 0){
printf("create work_thread fair!ssssssssssssssssssssssssss\n");
return ;
}
//等待对应的工作结束
pthread_join(tid,NULL);
//获取队列的长度
queue_length = Get_queue_Length(header);
queue_length = queue_length - 1;
header->queue_length = queue_length ;
printf("当前队列的长度:%d %d\n",queue_length,header->queue_length);
prev->next = p->next ;
free(p);
return prev ;
}运行结果：
程序还可以继续优化改进，并实现项目应用，且听下回分解。
