linux c隊列實現

c語言沒有隊列的數據結構，須要本身實現

//myqueue.h  

1. #ifndef __MYQUEUE_H__  
2. #define __MYQUEUE_H__  
3.   
4. #include <stdio.h>  
5. #include <stdlib.h>  
6.   
7. #define TRUE 1  
8. #define FALSE 0  
9. #define DBG(...) printf("myqueue %s, %d: ",__FUNCTION__,__LINE__);printf(__VA_ARGS__)  
10.   
11. #define MAXCNTBUF 1024*12  
12. typedef struct Point2D  
13. {  
14.     int len;  
15.     unsigned char buf[MAXCNTBUF ];  
16. }ElemType;     
17.   
18. typedef struct  
19. {  
20.     ElemType **rear;     
21.     ElemType *front;     
22.     int len;             
23.     int size;             
24.   
25.     pthread_mutex_t locker;      
26.     pthread_cond_t notEmpty;  
27.     pthread_cond_t notFull;  
28. }ArrQueue;       
29.   
30.   
31.   
32. ArrQueue *CreateQueue( int nLen)   ;       
33. void DestroyQueue( ArrQueue *pQueue );       
34. void ClearQueue( ArrQueue *pQueue );     
35. int GetLength( ArrQueue *pQueue );           
36. int GetSize( ArrQueue *pQueue );       
37. int IsEmpty( ArrQueue *pQueue );           
38. int GetHead( ArrQueue *pQueue, ElemType **pe );      
39. int EnQueue( ArrQueue *pQueue, ElemType *pe );         
40. int DeQueue( ArrQueue *pQueue, ElemType **pe );   
41. void ForEachQueue( ArrQueue *pQueue, void (*func)(ElemType *pe) );    
42. #endif  

 

1. //myqueue.c  
2. #include "myqueue.h"  
3. ArrQueue *CreateQueue( int nLen )  
4. {  
5.     ArrQueue *pQueue = (ArrQueue *)malloc( sizeof(ArrQueue) );  
6.     pQueue->rear = (ElemType **)calloc( nLen, sizeof(ElemType **) );  
7.     pQueue->front = pQueue->rear[0];  
8.     pQueue->len = 0;  
9.     pQueue->size = nLen;  
10.   
11.     pthread_mutex_init(&pQueue->locker,NULL);  
12.     pthread_cond_init(&pQueue->notEmpty,NULL);  
13.     pthread_cond_init(&pQueue->notFull,NULL);  
14.   
15.     return pQueue;  
16. }  
17.   
18. void DestroyQueue( ArrQueue *pQueue )  
19. {  
20.     free( pQueue->rear );  
21.     free( pQueue );  
22.   
23.     pthread_mutex_destroy(&pQueue->locker);  
24.     pthread_cond_destroy(&pQueue->notEmpty);  
25.     pthread_cond_destroy(&pQueue->notFull);  
26.   
27.     pQueue = NULL;  
28. }  
29.   
30. void ClearQueue( ArrQueue *pQueue )  
31. {  
32.     pQueue->front = pQueue->rear[0];  
33.   
34.     pQueue->len = 0;  
35. }  
36.   
37.   
38. int GetLength( ArrQueue *pQueue )  
39. {  
40.     return pQueue->len;  
41. }  
42.   
43.   
44. int GetSize( ArrQueue *pQueue )  
45. {  
46.     return pQueue->size;  
47. }  
48.   
49. int IsEmpty( ArrQueue *pQueue )  
50. {  
51.     return pQueue->len == 0 ? TRUE : FALSE;  
52. }  
53.   
54. int IsFull( ArrQueue *pQueue )  
55. {  
56. DBG("pQueue->len=%d,pQueue->size=%d\n",pQueue->len,pQueue->size);  
57.     return pQueue->len == pQueue->size? TRUE : FALSE;  
58. }  
59.   
60. int GetHead( ArrQueue *pQueue, ElemType **pe )  
61. {  
62.     if( pQueue->len == 0 )  
63.     {  
64.         *pe = NULL;  
65.         return -1;  
66.     }  
67.   
68.     *pe = pQueue->rear[pQueue->len-1];  
69.   
70.     return pQueue->len-1;  
71. }  
72.   
73. int EnQueue( ArrQueue *pQueue, ElemType *pe )  
74. {  
75.     pthread_mutex_lock(&pQueue->locker);  
76.   
77.     while (IsFull(pQueue))  
78.     {  
79.         DBG("\n");  
80.         pthread_cond_wait(&pQueue->notFull, &pQueue->locker);  
81.     }   
82.   
83.     int i = 0;  
84.     for( i = pQueue->len; i > 0; --i )  
85.     {  
86.         pQueue->rear[i] = pQueue->rear[i-1];  
87.     }  
88.     pQueue->rear[0] = pe;  
89.     pQueue->front = pQueue->rear[pQueue->len];  
90.   
91.      ++pQueue->len;  
92.   
93.     pthread_cond_signal(&pQueue->notEmpty);  
94.     pthread_mutex_unlock(&pQueue->locker);  
95.   
96. }  
97.   
98. int DeQueue( ArrQueue *pQueue, ElemType **pe )  
99. {  
100.   
101.     pthread_mutex_lock(&pQueue->locker);  
102.     while (IsEmpty(pQueue))  
103.     {  
104.         pthread_cond_wait(&pQueue->notEmpty, &pQueue->locker);  
105.     }  
106.   
107.   
108.     if( pQueue->len == 0 )  
109.     {  
110.         *pe = NULL;  
111.         return -1;  
112.     }  
113.   
114.     *pe = pQueue->front;  
115.   
116. DBG("len= %d,%x \n",(*pe)->len,(*pe)->len);  
117.   
118.     --pQueue->len;  
119.     pQueue->front = pQueue->rear[pQueue->len-1];  
120.   
121.     pthread_cond_signal(&pQueue->notFull);   
122.     pthread_mutex_unlock(&pQueue->locker);  
123.   
124.     return pQueue->len;  
125. }  
126.   
127.   
128. void ForEachQueue( ArrQueue *pQueue, void (*func)(ElemType *pe) )  
129. {  
130.     int i = 0;  
131.     for( i = 0; i < pQueue->len; ++i )  
132.     {  
133.         func( pQueue->rear[i] );  
134.     }  
135. }  

 

[cpp] view plain copy

 

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. #include <unistd.h>  
5. #include <pthread.h>  
6. #include <signal.h>  
7. #include "myqueue.h"  
8.  
9. void getqueue()  
10. {  
11.     ElemType *elememt;  
12.   
13.     while(1)  
14.         {  
15.         usleep(1000*20);  
16.             DeQueue( m_pque, &elememt );  
17.   
18.             if(elememt==NULL)  
19.             {  
20.                 printf("fdafsaf");  
21.                 DBG("d ReadOneNaluFromQueue elememt==NULL \n");  
22.             }  
23.   
24.                   
25.   
26.             int jj=0;  
27.             DBG("elememt.len=%d ,0x%x:",elememt->len,elememt->len);  
28.             for(jj=0;jj<10;jj++)  
29.                 printf("%x ",elememt->buf[jj]);  
30.                 printf("\n");  
31.             free( elememt);  
32.         }  
33.   
34. }  
35.   
36.   
37. void sendtoqueue()  
38. {  
39.   
40.     HI_S32 i;  
41.     int j=0;  
42.     ElemType *elememt=NULL;  
43.     static int ii=0;  
44.     while(1)  
45.     {  
46.   
47.   
48. system("free");  
49.                 elememt=(ElemType *)malloc(sizeof(ElemType));   
50.                   
51.                 if(elememt==NULL)  
52.                 {  
53.                     printf("0 malloc(sizeof(ElemType))");  
54.                     exit(0);  
55.                 }  
56.                 memset(elememt,0,sizeof(ElemType));  
57.                 elememt->buf[0]=ii;  
58.                 elememt->len=ii++;  
59.                   
60.                 int jj=0;  
61.                 DBG("elememt.len=%d ,0x%x:",elememt->len,elememt->len);  
62.                 for(jj=0;jj<10;jj++)  
63.                     printf("%x ",elememt->buf[jj]);  
64.                 printf("\n");  
65.                   
66.                 EnQueue( m_pque, elememt );  
67.   
68.   
69.         }   
70.   
71. }  
72.   
73. /****************************************************************************** 
74. * function    : main() 
75. * Description : video venc sample 
76. ******************************************************************************/  
77. int main(int argc, char *argv[])  
78. {  
79.   
80. #if 0  
81.   
82.     m_pque = CreateQueue( 20 );  
83. #if 1  
84.     pthread_t td;  
85.     int ret =pthread_create(&td,NULL,getqueue,NULL);  
86.     if(ret!=0){  
87.         printf("create thread err\n");  
88.     }  
89.   
90.     pthread_t td2;  
91.     ret =pthread_create(&td2,NULL,sendtoqueue,NULL);  
92.     if(ret!=0){  
93.         printf("create thread err\n");  
94.     }  
95.   
96.  #endif  
97.   
98.   
99. while(1)  
100.     sleep(1);