Linux 线程同步的三种方法(互斥锁、条件变量、信号量)

互斥锁

 #include <cstdio>

 #include <cstdlib>

 #include <unistd.h>

 #include <pthread.h>

 #include "iostream"

 using namespace std;

 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

 int tmp;

 void* thread(void *arg)

 {

     cout << "thread id is " << pthread_self() << endl;

     pthread_mutex_lock(&mutex);

     tmp = ;

     cout << "Now a is " << tmp << endl;

     pthread_mutex_unlock(&mutex);

     return NULL;

 }

 int main()

 {

     pthread_t id;

     cout << "main thread id is " << pthread_self() << endl;

     tmp = ;

     cout << "In main func tmp = " << tmp << endl;

     if (!pthread_create(&id, NULL, thread, NULL))

     {

         cout << "Create thread success!" << endl;

     }

     else

     {

         cout << "Create thread failed!" << endl;

     }

     pthread_join(id, NULL);

     pthread_mutex_destroy(&mutex);

     return ;

 }

 //编译：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()

    {

        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();

    }

    pthread_cleanup_pop();

}

void *thread2(void *arg)

{

    while()

    {

        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();

    }

}

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();

    do

    {

        pthread_cond_signal(&cond);

    }while();

    sleep();

    pthread_exit();

    return ;

}

#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 ()

    {

        //这个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();

    return ;

}

int main(void)

{

    pthread_t tid;

    int i;

    struct node *p;

    //子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而

    //不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大

    pthread_create(&tid, NULL, thread_func, NULL);

    sleep();

    for (i = ; i < ; 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();

    }

    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 ;

}

信号量

#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 = ;

    pthread_t pt_2 = ;

    int ret = ;

    PrivInfo* thiz = NULL;

    thiz = (PrivInfo* )malloc (sizeof (PrivInfo));

    if (thiz == NULL)

    {

        printf ("[%s]: Failed to malloc priv./n");

        return -;

    }

    info_init (thiz);

    ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);

    if (ret != )

    {

        perror ("pthread_1_create:");

    }

    ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);

    if (ret != )

    {

        perror ("pthread_2_create:");

    }

    pthread_join (pt_1, NULL);

    pthread_join (pt_2, NULL);

    info_destroy (thiz);

    return ;

}

static void info_init (PrivInfo* thiz)

{

    return_if_fail (thiz != NULL);

    thiz->end_time = time(NULL) + ;

    sem_init (&thiz->s1, , );

    sem_init (&thiz->s2, , );

    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 ();

    }

    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 ();

    }

    return;

}

总结：

互斥锁是是访问共享变量的，防止多线程同时写出现脏数据。

信号量是用来线程同步的，可两线程双向互相通知，也可单向通知。

条件变量是信号量的一种封装，用于线程单向等待另一个线程的通知，也可先后多个线程等待同一个条件变量的唤醒。

参考资料：https://blog.csdn.net/zsf8701/article/details/7844316