为什么多线程总会出现意外?-----关于信号量的学习.

yang_java2004

小弟现在学习信号量,写了个简单函数,简单改遍书上的例子!


写了个简单的程序如下:

1. 
   
2. 
   
3. typedef struct list{
   
4.        
   
5.         int                semop;
   
6.         int                buf[MAXITEM];
   
7.         int   threadid[MAXITEM];
   
8.         int                nput;
   
9.         int                nval;       
   
10. }LOCK_LIST;
    
11. 
    

复制代码

就是 N个线程对 buf 填充数据!   buf[0] 写0,buf[1]写1 ......,依次增加!

1. 
   
2. 
   
3. #include <sys/types.h>
   
4. #include <unistd.h>
   
5. #include <signal.h>
   
6. #include <string.h>
   
7. #include <stdio.h>
   
8. #include <stdlib.h>
   
9. #include <sys/stat.h>
   
10. #include <sys/ipc.h>
    
11. #include <sys/sem.h>
    
12. #include <stdarg.h>
    
13. #include <time.h>
    
14. #include <fcntl.h>
    
15. 
    
16. 
    
17. #define  MAXITEM                        100000
    
18. #define         MAXTHRED            10
    
19. #define  NBUFF                           10
    
20. 
    
21. #define  BASE_SEM                        0X6001
    
22. 
    
23. #define   min(X,Y)   (( X > Y )? Y : X)
    
24. 
    
25. 
    
26. void * consume(void *arg);
    
27. void * produce(void *arg);
    
28. 
    
29. 
    
30. typedef struct list{
    
31.        
    
32.         int                semop;
    
33.         int                buf[MAXITEM];
    
34.         int   threadid[MAXITEM];
    
35.         int                nput;
    
36.         int                nval;       
    
37. }LOCK_LIST;
    
38. 
    
39. LOCK_LIST  lock_list;
    
40. 
    
41. LOCK_LIST  lock_test[10];
    
42. 
    
43. int                nitems;
    
44. 
    
45. 
    
46. int main(int argc,        char **argv)
    
47. {
    
48.         int nthreads;
    
49.         int i,count[MAXTHRED],ret;
    
50.         pthread_t        tid_produce[MAXTHRED],tid_consume;
    
51.        
    
52.         nitems = min(atoi(argv[1]),                MAXITEM);
    
53.         nthreads = min(atoi(argv[2]),        MAXTHRED);
    
54.        
    
55.         pthread_setconcurrency();
    
56.        
    
57.         memset(&lock_list,                0,        sizeof(LOCK_LIST));
    
58.        
    
59.         /*init sem*/
    
60.         lock_list.semop = init_sem(BASE_SEM,1);
    
61.         if(lock_list.semop < 0)
    
62.         {
    
63.                         printf("init sem error[%d] .\n",lock_list.semop);
    
64.                         return -2;       
    
65.         }       
    
66.        
    
67.         /*start produce thread*/
    
68.         for(i = 0;        i < nthreads;        i++)
    
69.         {
    
70.                         count[i] = 0;
    
71.                         pthread_create(&tid_produce[i],        NULL,        produce,        &count[i]);       
    
72.         }
    
73.        
    
74.         printf("thread create succefully.\n");
    
75.        
    
76.         /*wait produce thread*/
    
77.         for(i = 0; i < nthreads; i++)
    
78.         {
    
79.                         pthread_join(tid_produce[i],        NULL);       
    
80.                         printf("count[%d]=%d\n",i,count[i]);
    
81.         }
    
82.        
    
83.         printf("thread realease succefully.\n");
    
84.        
    
85.         /*start consume thread*/
    
86.         pthread_create(&tid_consume,        NULL,        consume,        NULL);
    
87.         printf("consume start succefully.\n");
    
88.         pthread_join(tid_consume,        NULL);       
    
89.         printf("consume end succefully.\n");       
    
90.        
    
91.         /*release sem*/
    
92.         remove_sem(lock_list.semop);
    
93.                
    
94.         return 0;
    
95. }
    
96. 
    
97. int  init_sem(int key, int num)
    
98. {
    
99.                 int semid;
    
100.                 int opt = 0;
     
101.                 semid = semget(key,        num,        IPC_CREAT |0600);
     
102.                 if(semid == -1)
     
103.                 {
     
104.                         printf("semget error.\n");
     
105.                         return -1;       
     
106.                 }       
     
107.                
     
108.                 semctl(key,        0,        SETVAL, opt);
     
109.                
     
110.                 return semid;
     
111. }
     
112. 
     
113. 
     
114. int remove_sem(int semid)
     
115. {
     
116.         if (semctl(semid, 0, IPC_RMID) < 0) {
     
117.                 return -1;
     
118.         }
     
119. 
     
120.         return 0;
     
121. }
     
122. 
     
123. int lock_sem(int semid, int num)
     
124. {
     
125.                         struct sembuf ops[2];
     
126.                        
     
127.                         ops[0].sem_num = num;
     
128.                         ops[0].sem_op  = 0;
     
129.                         ops[0].sem_flg = 0;
     
130.                        
     
131.                         ops[1].sem_num        = num;
     
132.                         ops[1].sem_op   = 1;
     
133.                         ops[0].sem_flg  = SEM_UNDO;
     
134.                        
     
135.                         return semop(semid,        ops,        2);                       
     
136. }
     
137. 
     
138. int unlock_sem(int semid,        int num)
     
139. {
     
140.                  struct sembuf ops;
     
141.                  
     
142.                  ops.sem_num = num;
     
143.                  ops.sem_op =  -1;
     
144.                  ops.sem_flg = SEM_UNDO;
     
145.                  
     
146.                  return semop(semid,        &ops,        1);
     
147.        
     
148. }
     
149. 
     
150. void * produce(void *arg)
     
151. {
     
152.                 for( ; ; )
     
153.                 {
     
154.                                 lock_sem(lock_list.semop,        1);
     
155.                        
     
156.                                 if(lock_list.nput >= nitems)
     
157.                                 {
     
158.                                         unlock_sem(lock_list.semop,        1);
     
159.                                         return NULL;                                       
     
160.                                 }       
     
161.                                
     
162.                                 lock_list.buf[lock_list.nput] = lock_list.nval;
     
163.                                 lock_list.threadid[lock_list.nput] = pthread_self();
     
164.                                 lock_list.nput ++ ;
     
165.                                 lock_list.nval ++ ;
     
166.                                
     
167.                                
     
168.                                 unlock_sem(lock_list.semop,        1);
     
169.                                
     
170.                                 *((int *) arg) += 1 ;                               
     
171.                 }       
     
172. }
     
173. 
     
174. 
     
175. void *consume(void *arg)
     
176. {
     
177.                 int         i;
     
178.                 char file[1023];
     
179.                 FILE *fp;
     
180.                 int flag = 0;
     
181.                 char temp[1024];
     
182.                 for (        i = 0; i < nitems; i++)
     
183.                 {
     
184.                                 if(lock_list.buf[i] != i)
     
185.                                 {       
     
186.                                                 flag = 1;
     
187.                                                 printf("something error,id = %d ,num = %d.\n",i,lock_list.buf[i]);
     
188.                                                 break;
     
189.                                 }
     
190.                 }
     
191.                
     
192.                 if(flag)
     
193.                 {
     
194.                                 sprintf(file,"%s","2.log");
     
195.                                 if((fp = fopen(file,"w+")) == NULL)
     
196.                                 {
     
197.                                                 printf("open file error %s \n",file);       
     
198.                                 }       
     
199.                                 for (        i = 0; i < nitems; i++)
     
200.                                 {
     
201.                                                 memset(temp,        0,        sizeof(temp));
     
202.                                                 sprintf(temp,"%04d,%04d,pthread=%d\n",lock_list.buf[i],i,lock_list.threadid[i]);
     
203.                                                 fputs(temp,fp);
     
204.                                 }                               
     
205.                 }       
     
206.                        
     
207.                 return(NULL);
     
208. }
     
209. 
     

复制代码

==================================================================================



编译aix5)


cc -o locklist locklist.c  -lpthread


运行:



thread create succefully.
count[0]=2412
count[1]=2805
count[2]=1420
count[3]=596
count[4]=2817
thread realease succefully.
consume start succefully.
something error,id = 137 ,num = 0.
consume end succefully.


2.log 中的记录:


0134,0134,pthread=772
0135,0135,pthread=258
0136,0136,pthread=772
0000,0137,pthread=258                     /////////////////error/////////////////?????why???????
0138,0138,pthread=258
0139,0139,pthread=772
0140,0140,pthread=258
0141,0141,pthread=772
0142,0142,pthread=258
0143,0143,pthread=772
0144,0144,pthread=258



为什么总有不对的数据呢??而且频率很高,几乎每隔一次都产生...程序那有问题，请指点!!!!!


代码附:

soul_of_moon

建议编译的时候加上-Wall。
我的调试结果是系统处理不过来，导致某条++语句未执行

yang_java2004

原帖由 soul_of_moon 于 2008-1-4 14:15 发表
建议编译的时候加上-Wall。
我的调试结果是系统处理不过来，导致某条++语句未执行

哦~ 请教你是怎么做的？ 知道那个++ 未执行？

soul_of_moon

for( ; ; )
                {
                                lock_sem(lock_list.semop,        1);
                       
                                if(lock_list.nput != lock_list.nval)
                                        printf("before: %d, %d\n", lock_list.nput, lock_list.nval);

                                if(lock_list.nput >= nitems)
                                {
                                        unlock_sem(lock_list.semop,        1);
                                        return NULL;                                       
                                }      
                              
                                lock_list.buf[lock_list.nput] = lock_list.nval;
                                lock_list.threadid[lock_list.nput] = pthread_self();
                                lock_list.nput ++ ;
                                lock_list.nval ++ ;
                              
                               if(lock_list.nput != lock_list.nval)
                                        printf("after: %d, %d\n", lock_list.nput, lock_list.nval);

                                unlock_sem(lock_list.semop,        1);
                              
                                *((int *) arg) += 1 ;                              
                }   



后来加个usleep(10)就不再现了

yang_java2004

奇怪,你的是什么环境?

我怎么usleep(1000);都还会出现呢。.

soul_of_moon

你用这段程序试试看

#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdarg.h>
#include <time.h>
#include <fcntl.h>
#include <pthread.h>


#define  MAXITEM                        100000
#define         MAXTHRED            10
#define  NBUFF                           10

#define  BASE_SEM                        0X6001

#define   min(X,Y)   (( X > Y )? Y : X)

pthread_mutex_t mutex;

void * consume(void *arg);
void * produce(void *arg);
int  init_sem(int key, int num);
int remove_sem(int semid);

typedef struct list{
       
        int                semop;
        int                buf[MAXITEM];
        int   threadid[MAXITEM];
        int                nput;
        int                nval;       
}LOCK_LIST;

LOCK_LIST  lock_list;

int                nitems;


int main(int argc,        char **argv)
{
        int nthreads;
        int i,count[MAXTHRED];
        pthread_t        tid_produce[MAXTHRED],tid_consume;
       
        nitems = min(atoi(argv[1]),                MAXITEM);
        nthreads = min(atoi(argv[2]),        MAXTHRED);
       
        pthread_setconcurrency();
       
        memset(&lock_list,                0,        sizeof(LOCK_LIST));
       
        /*init sem*/
        lock_list.semop = init_sem(BASE_SEM,1);
        if(lock_list.semop < 0)
        {
                        printf("init sem error[%d] .\n",lock_list.semop);
                        return -2;       
        }       
       
        /*start produce thread*/
        for(i = 0;        i < nthreads;        i++)
        {
                        count = 0;
                        pthread_create(&tid_produce,        NULL,        produce,        &count);       
        }
       
        printf("thread create succefully.\n");
       
        /*wait produce thread*/
        for(i = 0; i < nthreads; i++)
        {
                        pthread_join(tid_produce,        NULL);       
                        printf("count[%d]=%d\n",i,count);
        }
       
        printf("thread realease succefully.\n");
       
        /*start consume thread*/
        pthread_create(&tid_consume,        NULL,        consume,        NULL);
        printf("consume start succefully.\n");
        pthread_join(tid_consume,        NULL);       
        printf("consume end succefully.\n");       
       
        /*release sem*/
        remove_sem(lock_list.semop);
               
        return 0;
}

int  init_sem(int key, int num)
{
        /*
                int semid;
                int opt = 0;
                semid = semget(key,        num,        IPC_CREAT |0600);
                if(semid == -1)
                {
                        printf("semget error.\n");
                        return -1;       
                }       
               
                semctl(key,        0,        SETVAL, opt);
               
                return semid;
                */
                pthread_mutex_init(&mutex, NULL);
                return 0;
}


int remove_sem(int semid)
{
//        if (semctl(semid, 0, IPC_RMID) < 0) {
//                return -1;
//        }

        pthread_mutex_destroy(&mutex);

        return 0;
}

int lock_sem(int semid, int num)
{
        pthread_mutex_lock(&mutex);

        return 0;
//                        struct sembuf ops[2];
//                       
//                        ops[0].sem_num = num;
//                        ops[0].sem_op  = 0;
//                        ops[0].sem_flg = 0;
//                       
//                        ops[1].sem_num        = num;
//                        ops[1].sem_op   = 1;
//                        ops[1].sem_flg  = SEM_UNDO;
//                       
//                        return semop(semid,        ops,        2);                       
}

int unlock_sem(int semid,        int num)
{
//                 struct sembuf ops;
//                 
//                 ops.sem_num = num;
//                 ops.sem_op =  -1;
//                 ops.sem_flg = SEM_UNDO;
//                 
//                 return semop(semid,        &ops,        1);
       
        pthread_mutex_unlock(&mutex);
        return 0;
}

void * produce(void *arg)
{
                for( ; ; )
                {
                                lock_sem(lock_list.semop,        1);
                       
                                if(lock_list.nput != lock_list.nval)
                                        printf("before: %d, %d\n", lock_list.nput, lock_list.nval);
                       
                                if(lock_list.nput >= nitems)
                                {
                                        unlock_sem(lock_list.semop,        1);
                                        return NULL;                                       
                                }       
                               
                                lock_list.buf[lock_list.nput] = lock_list.nval;
                                lock_list.threadid[lock_list.nput] = pthread_self();
                                lock_list.nput ++ ;
                                lock_list.nval ++ ;
                               
                                if(lock_list.nput != lock_list.nval)
                                        printf("after: %d, %d\n", lock_list.nput, lock_list.nval);
//                                usleep(10);
                               
                                unlock_sem(lock_list.semop,        1);
                               
                                *((int *) arg) += 1 ;                               
                }       
}


void *consume(void *arg)
{
                int         i;
                char file[1023];
                FILE *fp;
                int flag = 0;
                char temp[1024];
                for (        i = 0; i < nitems; i++)
                {
                                if(lock_list.buf != i)
                                {       
                                                flag = 1;
                                                printf("something error,id = %d ,num = %d.\n",i,lock_list.buf);
                                                break;
                                }
                }
               
                if(flag)
                {
                                sprintf(file,"%s","2.log");
                                if((fp = fopen(file,"w+")) == NULL)
                                {
                                                printf("open file error %s \n",file);       
                                }       
                                for (        i = 0; i < nitems; i++)
                                {
                                                memset(temp,        0,        sizeof(temp));
                                                sprintf(temp,"%04d,%04d,pthread=%d\n",lock_list.buf,i,lock_list.threadid);
                                                fputs(temp,fp);
                                }                               
                }       
                       
                return(NULL);
}

ljok30

有几个问题，
1，你的程序想达到什么效果，"N个线程对 buf 填充数据!   buf[0] 写0,buf[1]写1 ......,依次增加!",如果你不加usleep，那么实际上就第一个线程去填充，其他的就不会去填充了。
2，如果你的nitems小于线程数，那么第nitems个线程就没有什么意义了
3，不知道你什么环境，我在ES4.0下运行完全没有问题，不管有没有usleep

yang_java2004

to: soul_of_moon

用互斥锁不会出现这种情况~~ 但为啥信号量就不行呢？奇怪..

编译器：

  C for AIX Compiler, Version 5

  Usage:
     xlc [ option | inputfile ]...
     cc [ option | inputfile ]...
     c89 [ option | inputfile ]...
     xlc128 [ option | inputfile ]...
     cc128 [ option | inputfile ]...
     xlc_r [ option | inputfile ]...
     cc_r [ option | inputfile ]...
     xlc_r4 [ option | inputfile ]...
     cc_r4 [ option | inputfile ]...
     xlc_r7 [ option | inputfile ]...
     cc_r7 [ option | inputfile ]...






to : ljok30



"1，你的程序想达到什么效果，"N个线程对 buf 填充数据!   buf[0] 写0,buf[1]写1 ......,依次增加!",如果你不加usleep，那么实际上就第一个线程去填充，其他的就不会去填充了。
"

这个理解应该有误，我设置了线程并发,当数据量大，比如我测试的10000 5 的时候，肯定会好几个线程处理的。


“3，不知道你什么环境，我在ES4.0下运行完全没有问题，不管有没有usleep”

我现在怀疑是不是跟我的环境有关系，但又找不到原因～～

yang_java2004

终于找到原因了～

我犯了一个极低级的错误．．

楼上的两位大哥别怪我啊。。。

锁加错了～～

没脸再发帖了～