Linux 線程同步的三種方法(互斥鎖、條件變量、信號量)

時間  2019-12-14
標籤 linux 線程 同步 三種 方法 互斥 條件 變量 信號 欄目 Linux 简体版
原文   原文鏈接

互斥鎖

 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;

}

 

總結：

互斥鎖是是訪問共享變量的，防止多線程同時寫出現髒數據。node

信號量是用來線程同步的，可兩線程雙向互相通知，也可單向通知。ios

條件變量是信號量的一種封裝，用於線程單向等待另外一個線程的通知，也可前後多個線程等待同一個條件變量的喚醒。多線程

 

參考資料：https://blog.csdn.net/zsf8701/article/details/7844316併發

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程