线程

yesblue77

pthread, POSIX线程。

线程间的切换的话，不用像进程间那样需要完整的上下文切换，从而节省开销。

__clone函数调用

__clone的目的是为了更容易实现pthread库。
Linux私有函数__clone是fork的替代函数，她能够更多控制父进程和子进程之间共享那些进程资源。

#include <sched.h>
int __clone(int (*fn)(void *fnarg), void *child_stack, int flags, void *arg);

pthread接口

pthread = c函数调用 + 数据结构 + <pthread.h> + libpthread.so

pthread_create

#include <pthread.h>
int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

pthread_exit

void pthread_exit(void *retval);

pthread_join

挂起当前线程，直到th指定的线程终止运行为止。

int pthread_join(pthread_t th, void **thread_return);
int pthread_detach(pthread_t th);

一个线程所使用的内存资源在对该线程应用pthread_join之前不会被重新分配，所以对于可切入的线程必须调用一次join函数。

pthread_cancel

int pthread_setcancelstate(int state, it *oldstate);
int pthread_cancel(pthread_t thread);

code sample for pthread_create

 

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

pthread条件

用于挂起当前线程知道满足条件为止。

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
int pthread_cond_destroy(pthread_cond_t *cond);

singal & broadcast用于重启等待条件的线程。
wait & timewait 解开mutex指出的一个mutex, 然后等待变量cond上的信号。

互斥

mutex = mutual exclusion, 是一种锁或者信号灯。

一个互斥锁只有两种状态: locked , unlocked.

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t * mutexatrr);
int pthread_mutex_lock(pthread_mutex_t * mutex);
int pthread_mutex_trylock(pthrad_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

code sample for mutex:

 

1. /*
   
2.  * mutex.c - using mutex
   
3.  */
   
4. #include <pthread.h>
   
5. #include <unistd.h>
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <errno.h>
   
9. 
   
10. #define INDEX 10000000
    
11. long int ticks;
    
12. time_t end_time;
    
13. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
14. 
    
15. void err_quit(char *msg);
    
16. void idx_th(void *arg);
    
17. void mon_th(void *arg);
    
18. 
    
19. int main(int argc, char *argv[]) {
    
20.   pthread_t idx_th_id;
    
21.   pthread_t mon_th_id;
    
22.   int ret;
    
23. 
    
24.   end_time = time(NULL) + 30; /* 30s */
    
25. 
    
26.   ret = pthread_create(&idx_th_id, NULL, (void*)idx_th, NULL);
    
27.   if (ret) err_quit("pthread_create; idx_th");
    
28.   ret = pthread_create(&mon_th_id, NULL, (void*)mon_th, NULL);
    
29.   if (ret) err_quit("pthread_create; mon_th");
    
30. 
    
31.   pthread_join(idx_th_id, NULL);
    
32.   pthread_join(mon_th_id, NULL);
    
33. 
    
34.   exit(EXIT_SUCCESS);
    
35. }
    
36. 
    
37. /* increase the ticks */
    
38. void idx_th(void *arg) {
    
39.   long l;
    
40.   int ret;
    
41. 
    
42.   while (time(NULL) < end_time) {
    
43.     ret = pthread_mutex_lock(&mutex);
    
44.     if (ret) err_quit("pthread_mutex_lock");
    
45. 
    
46.     for (l = 0l; l < INDEX; l++) {
    
47.       ticks++;
    
48.     }
    
49. 
    
50.     ret = pthread_mutex_unlock(&mutex);
    
51.     if (ret) err_quit("pthread_mutex_unlock");
    
52.     sleep(1);
    
53.   }
    
54. }
    
55. 
    
56. /* monitor the ticks */
    
57. void mon_th(void *arg) {
    
58.   int nolock = 0;
    
59.   int ret;
    
60. 
    
61.   while (time(NULL) < end_time) {
    
62.     sleep(3);
    
63. 
    
64.     ret = pthread_mutex_trylock(&mutex);
    
65.     if (ret != EBUSY) {
    
66.       if (ret) err_quit("pthread_mutex_trylock");
    
67.       printf("mon_th: got lock at %ld ticks\n", ticks);
    
68.       ret = pthread_mutex_unlock(&mutex);
    
69.       if (ret) err_quit("pthread_mutex_unlock");
    
70.     } else {
    
71.       nolock++;
    
72.     }
    
73.   }
    
74.   printf("mon_th missed lock %d times\n", nolock);
    
75. }
    
76. 
    
77. void err_quit(char *msg) {
    
78.   perror(msg);
    
79.   exit(EXIT_FAILURE);
    
80. }