关于线程的基本问题

andy007

一个进程产生了一些线程以后，那么这个主进程和线程之间是什么关系？怎样联系？

请看下列这段代码：

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <pthread.h>
   
5. 
   
6. void task1(int *counter);
   
7. void task2(int *counter);
   
8. void cleanup(int counter1, int counter2);
   
9. 
   
10. int g1 = 0;
    
11. int g2 = 0;
    
12. 
    
13. int main(int argc, char *argv[])
    
14. {
    
15.         pthread_t thrd1, thrd2;
    
16.         int ret;
    
17. 
    
18.         ret = pthread_create(&thrd1, NULL, (void *)task1, (void *)&g1);
    
19.         if (ret) {
    
20.                 perror("pthread_create: task1");
    
21.                 exit(EXIT_FAILURE);
    
22.         }
    
23.         ret = pthread_create(&thrd2, NULL, (void *)task2, (void *)&g2);
    
24.         if (ret) {
    
25.                 perror("pthread_create: task2");
    
26.                 exit(EXIT_FAILURE);
    
27.         }
    
28. 
    
29.         pthread_join(thrd2, NULL);
    
30.         pthread_join(thrd1, NULL);
    
31. 
    
32.         cleanup(g1, g2);
    
33. 
    
34.         exit(EXIT_SUCCESS);
    
35. }
    
36. 
    
37. void task1(int *counter)
    
38. {
    
39.         while (*counter < 5) {
    
40.                 printf("task1 count: %d\n", *counter);
    
41.                 (*counter)++;
    
42.                 sleep(1);
    
43.         }
    
44. }
    
45. 
    
46. void task2(int *counter)
    
47. {
    
48.         while (*counter < 5) {
    
49.                 printf("task2 count: %d\n", *counter);
    
50.                 (*counter)++;
    
51.         }
    
52. }
    
53. 
    
54. void cleanup(int counter1, int counter2)
    
55. {
    
56.         printf("total iterations: %d\n", counter1 + counter2);
    
57. }
    

复制代码

其中调用了两次pthread_join使指定的线程挂起。因此可以看到线程一执行完后，线程2才开始执行。但如果我去掉这两句，那么线程1（执行task1的线程）输出一行后，便是线程2输出。通过多次的运行，线程2的输出次数不定。而线程一肯定是只输出一次，并且一定是在第一行输出。那么请问这种现象是怎么回事？

doubleelec

pthread_join不是挂起指定的线程,而是调用线程挂起以等待指定的线程执行结束
当有这两句时,我这里输出结果是
task1 count: 0
task2 count: 0
task2 count: 1
task2 count: 2
task2 count: 3
task2 count: 4
task1 count: 1
task1 count: 2
task1 count: 3
task1 count: 4
total iterations: 10
因为线程1输出后调用了sleep(1)睡了一秒
而线程2连续输出,所以出现上述情况

而当没有这两句时,我这里输出是
task1 count: 0
task2 count: 0
task2 count: 1
task2 count: 2
task2 count: 3
task2 count: 4
total iterations: 6
这是因为主线程不等待子线程执行结束就计算total并退出了
在主线程退出前,线程1没有来得及输出后四次(因为sleep)

doubleelec

你那里线程2的输出次数不定是因为线程2有时来得及而有时来不及完成任务就被迫终止了
这正体现了进程调度的不确定性

andy007

哦！去掉两个语句的时候没竟然没注意task1的sleep语句。谢谢！
我还有一点不明白，当第一次调用pthread_join的时候，线程1（执行task1的线程）被挂起，线程2执行完后线程1继续执行。代码明明是在主进程中，为什么挂起的是线程1？如果我有三个以上线程时执行这个调用，那么它挂起哪个线程？

PS：不好意思，家里没有装linux，所以无法自己去检验

doubleelec

挂起的不是线程1, 是主线程

doubleelec

挂起的不是线程1, 是主线程

学编程一定要找地方上机,只看书会留下一些错误的印象

lucifer

呵呵，看书仔细也就没问题了。明明man写的是thread_join  suspends the execution of the calling thread until ...知道calling thread什么意思的话，怎么也不会理解错了啊。

andy007

最初由 doubleelec 发表
挂起的不是线程1, 是主线程

原始进程就成了主线程,同时它也是线程1?要不为什么挂起主线程的时候线程1被延迟执行

doubleelec

你说的线程1指什么?
现在有三个线程:main, task1, task2
在main中等待task1和task2执行结束后才cleanup(g1, g2);
task1被延迟是因为sleep(1)

andy007

哦,明白,谢谢了