Linux 線程同步的三種方法(互斥鎖、條件變量、信號量)
阿新 • • 發佈：2018-12-02
另一個 雙向 fin lee ces 僅支持 lin from str
互斥鎖
1 #include <cstdio> 2 3 #include <cstdlib> 4 5 #include <unistd.h> 6 7 #include <pthread.h> 8 9 #include "iostream" 10 11 using namespace std; 12 13 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 14 15 int tmp; 16 17 void* thread(void *arg) 18 19 {20 21 cout << "thread id is " << pthread_self() << endl; 22 23 pthread_mutex_lock(&mutex); 24 25 tmp = 12; 26 27 cout << "Now a is " << tmp << endl; 28 29 pthread_mutex_unlock(&mutex); 30 31 return NULL; 32 33 } 34 35 int main()36 37 { 38 39 pthread_t id; 40 41 cout << "main thread id is " << pthread_self() << endl; 42 43 tmp = 3; 44 45 cout << "In main func tmp = " << tmp << endl; 46 47 if (!pthread_create(&id, NULL, thread, NULL)) 48 49 { 50 51 cout << "Create thread success!" << endl; 52 53 } 54 55 else 56 57 { 58 59 cout << "Create thread failed!" << endl; 60 61 } 62 63 pthread_join(id, NULL); 64 65 pthread_mutex_destroy(&mutex); 66 67 return 0; 68 69 } 70 71 //編譯：g++ -o thread testthread.cpp -lpthread
條件變量
#include <stdio.h> #include <pthread.h> #include "stdlib.h" #include "unistd.h" pthread_mutex_t mutex; pthread_cond_t cond; void hander(void *arg) { free(arg); (void)pthread_mutex_unlock(&mutex); } void *thread1(void *arg) { pthread_cleanup_push(hander, &mutex); while(1) { printf("thread1 is running\n"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread1 applied the condition\n"); pthread_mutex_unlock(&mutex); sleep(4); } pthread_cleanup_pop(0); } void *thread2(void *arg) { while(1) { printf("thread2 is running\n"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread2 applied the condition\n"); pthread_mutex_unlock(&mutex); sleep(1); } } int main() { pthread_t thid1,thid2; printf("condition variable study!\n"); pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL); pthread_create(&thid1, NULL, thread1, NULL); pthread_create(&thid2, NULL, thread2, NULL); sleep(1); do { pthread_cond_signal(&cond); }while(1); sleep(20); pthread_exit(0); return 0; }
#include <pthread.h> #include <unistd.h> #include "stdio.h" #include "stdlib.h" static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; struct node { int n_number; struct node *n_next; }*head = NULL; static void cleanup_handler(void *arg) { printf("Cleanup handler of second thread./n"); free(arg); (void)pthread_mutex_unlock(&mtx); } static void *thread_func(void *arg) { struct node *p = NULL; pthread_cleanup_push(cleanup_handler, p); while (1) { //這個mutex主要是用來保證pthread_cond_wait的並發性 pthread_mutex_lock(&mtx); while (head == NULL) { //這個while要特別說明一下，單個pthread_cond_wait功能很完善，為何 //這裏要有一個while (head == NULL)呢？因為pthread_cond_wait裏的線 //程可能會被意外喚醒，如果這個時候head != NULL，則不是我們想要的情況。 //這個時候，應該讓線程繼續進入pthread_cond_wait // pthread_cond_wait會先解除之前的pthread_mutex_lock鎖定的mtx， //然後阻塞在等待對列裏休眠，直到再次被喚醒(大多數情況下是等待的條件成立 //而被喚醒，喚醒後，該進程會先鎖定先pthread_mutex_lock(&mtx);，再讀取資源 //用這個流程是比較清楚的 pthread_cond_wait(&cond, &mtx); p = head; head = head->n_next; printf("Got %d from front of queue/n", p->n_number); free(p); } pthread_mutex_unlock(&mtx); //臨界區數據操作完畢，釋放互斥鎖 } pthread_cleanup_pop(0); return 0; } int main(void) { pthread_t tid; int i; struct node *p; //子線程會一直等待資源，類似生產者和消費者，但是這裏的消費者可以是多個消費者，而 //不僅僅支持普通的單個消費者，這個模型雖然簡單，但是很強大 pthread_create(&tid, NULL, thread_func, NULL); sleep(1); for (i = 0; i < 10; i++) { p = (struct node*)malloc(sizeof(struct node)); p->n_number = i; pthread_mutex_lock(&mtx); //需要操作head這個臨界資源，先加鎖， p->n_next = head; head = p; pthread_cond_signal(&cond); pthread_mutex_unlock(&mtx); //解鎖 sleep(1); } printf("thread 1 wanna end the line.So cancel thread 2./n"); //關於pthread_cancel，有一點額外的說明，它是從外部終止子線程，子線程會在最近的取消點，退出 //線程，而在我們的代碼裏，最近的取消點肯定就是pthread_cond_wait()了。 pthread_cancel(tid); pthread_join(tid, NULL); printf("All done -- exiting/n"); return 0; }
信號量
#include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <pthread.h> #include <semaphore.h> #include <errno.h> #define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;} typedef struct _PrivInfo { sem_t s1; sem_t s2; time_t end_time; }PrivInfo; static void info_init (PrivInfo* thiz); static void info_destroy (PrivInfo* thiz); static void* pthread_func_1 (PrivInfo* thiz); static void* pthread_func_2 (PrivInfo* thiz); int main (int argc, char** argv) { pthread_t pt_1 = 0; pthread_t pt_2 = 0; int ret = 0; PrivInfo* thiz = NULL; thiz = (PrivInfo* )malloc (sizeof (PrivInfo)); if (thiz == NULL) { printf ("[%s]: Failed to malloc priv./n"); return -1; } info_init (thiz); ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz); if (ret != 0) { perror ("pthread_1_create:"); } ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz); if (ret != 0) { perror ("pthread_2_create:"); } pthread_join (pt_1, NULL); pthread_join (pt_2, NULL); info_destroy (thiz); return 0; } static void info_init (PrivInfo* thiz) { return_if_fail (thiz != NULL); thiz->end_time = time(NULL) + 10; sem_init (&thiz->s1, 0, 1); sem_init (&thiz->s2, 0, 0); return; } static void info_destroy (PrivInfo* thiz) { return_if_fail (thiz != NULL); sem_destroy (&thiz->s1); sem_destroy (&thiz->s2); free (thiz); thiz = NULL; return; } static void* pthread_func_1 (PrivInfo* thiz) { return_if_fail(thiz != NULL); while (time(NULL) < thiz->end_time) { sem_wait (&thiz->s2); printf ("pthread1: pthread1 get the lock./n"); sem_post (&thiz->s1); printf ("pthread1: pthread1 unlock/n"); sleep (1); } return; } static void* pthread_func_2 (PrivInfo* thiz) { return_if_fail (thiz != NULL); while (time (NULL) < thiz->end_time) { sem_wait (&thiz->s1); printf ("pthread2: pthread2 get the unlock./n"); sem_post (&thiz->s2); printf ("pthread2: pthread2 unlock./n"); sleep (1); } return; }
總結：
互斥鎖是是訪問共享變量的，防止多線程同時寫出現臟數據。
信號量是用來線程同步的，可兩線程雙向互相通知，也可單向通知。
條件變量是信號量的一種封裝，用於線程單向等待另一個線程的通知，也可先後多個線程等待同一個條件變量的喚醒。
參考資料：https://blog.csdn.net/zsf8701/article/details/7844316
Linux 線程同步的三種方法(互斥鎖、條件變量、信號量)