嵌入式 linux下多线程同步问题

现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。
1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2互斥量:为协调共同对一个共享资源的单独访问而设计的。
3信号量:为控制一个具有有限数量用户资源而设计。
4事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。

线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。

1）互斥锁（mutex）

    通过锁机制实现线程间的同步。同一时刻只允许一个线程执行一个关键部分的代码。

int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);

int pthread_mutex_lock(pthread_mutex *mutex);

int pthread_mutex_destroy(pthread_mutex *mutex);

int pthread_mutex_unlock(pthread_mutex *

(1)先初始化锁init()或静态赋值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER

attr_t有:

PTHREAD_MUTEX_TIMED_NP:其余线程等待队列

PTHREAD_MUTEX_RECURSIVE_NP:嵌套锁,允许线程多次加锁,不同线程,解锁后重新竞争

PTHREAD_MUTEX_ERRORCHECK_NP:检错,与一同,线程请求已用锁,返回EDEADLK;

PTHREAD_MUTEX_ADAPTIVE_NP:适应锁,解锁后重新竞争

(2)加锁,lock,trylock,lock阻塞等待锁,trylock立即返回EBUSY

(3)解锁,unlock需满足是加锁状态,且由加锁线程解锁

(4)清除锁,destroy(此时锁必需unlock,否则返回EBUSY,//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 = 12 ;

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

   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 0;

}

编译： g++ -o thread testthread.cpp -lpthread

说明：pthread库不是Linux系统默认的库，连接时需要使用静态库libpthread.a，所以在使用pthread_create()创建线程，以及调用pthread_atfork()函数建立fork处理程序时，需要链接该库。在编译中要加 -lpthread参数。

2）条件变量（cond）

    利用线程间共享的全局变量进行同步的一种机制。条件变量上的基本操作有：触发条件(当条件变为 true 时)；等待条件，挂起线程直到其他线程触发条件。

int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);  

int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);

int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);  //解除所有线程的阻塞

(1)初始化.init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER（前者为动态初始化，后者为静态初始化）;属性置为NULL

(2)等待条件成立.pthread_wait,pthread_timewait.wait()释放锁,并阻塞等待条件变量为真，timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)

(3)激活条件变量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)

(4)清除条件变量:destroy;无线程等待,否则返回EBUSY

对于

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

一定要在mutex的锁定区域内使用。

    如果要正确的使用pthread_mutex_lock与pthread_mutex_unlock，请参考

pthread_cleanup_push和pthread_cleanup_pop宏，它能够在线程被cancel的时候正确的释放mutex！

    另外，posix1标准说，pthread_cond_signal与pthread_cond_broadcast无需考虑调用线程是否是mutex的拥有者，也就是说，可以在lock与unlock以外的区域调用。如果我们对调用行为不关心，那么请在lock区域之外调用吧。

说明：

    (1)pthread_cond_wait 自动解锁互斥量(如同执行了pthread_unlock_mutex)，并等待条件变量触发。这时线程挂起，不占用CPU时间，直到条件变量被触发（变量为ture）。在调用 pthread_cond_wait之前，应用程序必须加锁互斥量。pthread_cond_wait函数返回前，自动重新对互斥量加锁(如同执行了pthread_lock_mutex)。

    (2)互斥量的解锁和在条件变量上挂起都是自动进行的。因此，在条件变量被触发前，如果所有的线程都要对互斥量加锁，这种机制可保证在线程加锁互斥量和进入等待条件变量期间，条件变量不被触发。条件变量要和互斥量相联结，以避免出现条件竞争——个线程预备等待一个条件变量，当它在真正进入等待之前，另一个线程恰好触发了该条件（条件满足信号有可能在测试条件和调用pthread_cond_wait函数（block）之间被发出，从而造成无限制的等待）。

(3)pthread_cond_timedwait 和 pthread_cond_wait 一样，自动解锁互斥量及等待条件变量，但它还限定了等待时间。如果在abstime指定的时间内cond未触发，互斥量mutex被重新加锁，且pthread_cond_timedwait返回错误 ETIMEDOUT。abstime 参数指定一个绝对时间，时间原点与 time 和gettimeofday 相同：abstime = 0 表示 1970年1月1日00:00:00 GMT。

(4)pthread_cond_destroy 销毁一个条件变量，释放它拥有的资源。进入 pthread_cond_destroy 之前，必须没有在该条件变量上等待的线程。

    (5)条件变量函数不是异步信号安全的，不应当在信号处理程序中进行调用。特别要注意，如果在信号处理程序中调用 pthread_cond_signal 或pthread_cond_boardcast 函数，可能导致调用线程死锁。

示例程序1

#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 runningn" );
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        printf( "thread1 applied the conditionn" );
        pthread_mutex_unlock(&mutex);
        sleep( 4 );
    }
    pthread_cleanup_pop( 0 );
}

void *thread2(void *arg)
{
   while ( 1 )
   {
       printf( "thread2 is runningn" );
       pthread_mutex_lock(&mutex);
       pthread_cond_wait(&cond,&mutex);
       printf( "thread2 applied the conditionn" );
       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;
}

示例程序2：

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

/*[thread_func]*/
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);，再读取资源
        //用这个流程是比较清楚的/*block-->unlock-->wait() return-->lock*/
        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;
}

3）信号量

    如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。

    信号量函数的名字都以"sem_"打头。线程使用的基本信号量函数有四个。

#include <semaphore.h>

int sem_init (sem_t *sem , int pshared, unsigned int value);

    这是对由sem指定的信号量进行初始化，设置好它的共享选项（linux 只支持为0，即表示它是当前进程的局部信号量），然后给它一个初始值VALUE。

两个原子操作函数：

int sem_wait(sem_t *sem);

int sem_post(sem_t *sem);

    这两个函数都要用一个由sem_init调用初始化的信号量对象的指针做参数。

sem_post：给信号量的值加1；

sem_wait:给信号量减1；对一个值为0的信号量调用sem_wait,这个函数将会等待直到有其它线程使它不再是0为止。

int sem_destroy(sem_t *sem);

    这个函数的作用是再我们用完信号量后都它进行清理。归还自己占有的一切资源。

示例代码：

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

通 过执行结果后，可以看出，会先执行线程二的函数，然后再执行线程一的函数。它们两就实现了同步。在上大学的时候，虽然对这些概念知道，可都没有实践过，所 以有时候时间一久就会模糊甚至忘记，到了工作如果还保持这么一种状态，那就太可怕了。虽然现在外面的技术在不断的变化更新，可是不管怎么变，其核心技术还 是依旧的，所以我们必须要打好自己的基础，再学习其他新的知识，那时候再学新的知识也会觉得比较简单的。

 

l         互斥体Mutex

l         信号灯Semophore

l         条件变量Conditions

什么时候会用上互斥量了？比如你现在有一全局链表，你有几个工作线程。每一个线程从该链表中取出头节点，然后对该头节点进行处理。比如现在线程1正在取出头节点，他的操作如下：

Item * p =queue_list; Queue_list=queue_list->next; Process_job(p); Free(p);

当线程1处理完第一步，也就是Item *p=queue_list后，这时候系统停止线程1的运行，改而运行线程2。线程2照样取出头节点，然后进行处理，最后释放了该节点。过了段时间，线程1重新得到运行。而这个时候，其实p所指向的节点已经被线程2释放掉，而线程1对此毫无知晓。他会接着运行process_job(p)。而这将导致无法预料的后果！

对于这种情况，系统给我们提供了互斥量。你在取出头节点前必须要等待互斥量，如果此时有其他线程已经获得该互斥量，那么线程将会阻塞在这个地方。只有等到其他线程释放掉该互斥量后，你的线程才有可能得到该互斥量。为什么是可能了？因为可能此时有不止你一个线程在等候该互斥量，而系统无法保证你的线程将会优先运行。

互斥量的类型为pthread_mutex_t。你可以声明多个互斥量。在声明该变量后，你需要调用pthread_mutex_init()来创建该变量。pthread_mutex_init的格式如下：

int  pthread_mutex_init(pthread_mutex_t  *mutex,  const  pthread_mutex-

       attr_t *mutexattr);

第一个参数，mutext，也就是你之前声明的那个互斥量，第二个参数为该互斥量的属性。这个将在后面详细讨论。

在创建该互斥量之后，你便可以使用它了。要得到互斥量，你需要调用下面的函数：

int pthread_mutex_lock(pthread_mutex_t *mutex);

该函数用来给互斥量上锁，也就是我们前面所说的等待操作。互斥量一旦被上锁后，其他线程如果想给该互斥量上锁，那么就会阻塞在这个操作上。如果在此之前该互斥量已经被其他线程上锁，那么该操作将会一直阻塞在这个地方，直到获得该锁为止。

在得到互斥量后，你就可以进入关键代码区了。

同样，在操作完成后，你必须调用下面的函数来给互斥量解锁，也就是前面所说的释放。这样其他等待该锁的线程才有机会获得该锁，否则其他线程将会永远阻塞。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

下面给出一个简单的例子：

#include <malloc.h> #include <pthread.h> struct job { /* Link field for linked list. */ struct job* next; /* Other fields describing work to be done... */ }; /* A linked list of pending jobs. */ struct job* job_queue; /* A mutex protecting job_queue. */ pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER; /* Process queued jobs until the queue is empty. */ void* thread_function (void* arg) { while (1) { struct job* next_job; /* Lock the mutex on the job queue. */ pthread_mutex_lock (&job_queue_mutex); /* Now it’s safe to check if the queue is empty. */ if (job_queue == NULL) next_job = NULL; else { /* Get the next available job. */ next_job = job_queue; /* Remove this job from the list. */ job_queue = job_queue->next; } /* Unlock the mutex on the job queue because we’re done with the queue for now. */ pthread_mutex_unlock (&job_queue_mutex); /* Was the queue empty? If so, end the thread. */ if (next_job == NULL) break; /* Carry out the work. */ process_job (next_job); /* Clean up. */ free (next_job); } return NULL; }

在这个例子中我们使用了下面一条语句：

pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;

       他的作用和调用pthread_mutex_init()函数一样。

如果一个线程已经给一个互斥量上锁了，后来在操作的过程中又再次调用了该上锁的操作，那么该线程将会无限阻塞在这个地方，从而导致死锁。怎么变了？这就需要我们之前所提到的互斥量的属性。

互斥量分为下面三种：

l         快速型。这种类型也是默认的类型。该线程的行为正如上面所说的。

l         递归型。如果遇到我们上面所提到的死锁情况，同一线程循环给互斥量上锁，那么系统将会知道该上锁行为来自同一线程，那么就会同意线程给该互斥量上锁。

l         错误检测型。如果该互斥量已经被上锁，那么后续的上锁将会失败而不会阻塞，pthread_mutex_lock()操作将会返回EDEADLK。

互斥量的属性类型为pthread_mutexattr_t。声明后调用pthread_mutexattr_init()来创建该互斥量。然后调用int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);来设置属性。int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);格式如下：

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);

第一个参数，attr，就是前面声明的属性变量，第二个参数,kind，就是我们要设置的属性类型。他有下面几个选项：

l         PTHREAD_MUTEX_FAST_NP

l         PTHREAD_MUTEX_RECURSIVE_NP

l         PTHREAD_MUTEX_ERRORCHECK_NP

下面给出一个使用属性的简单过程：

pthread_mutex_t mutex; pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP); pthread_mutex_init(&mutex,&attr); pthread_mutex_destroy(&attr);

前面我们提到在调用pthread_mutex_lock()的时候，如果此时mutex已经被其他线程上锁，那么该操作将会一直阻塞在这个地方。如果我们此时不想一直阻塞在这个地方，那么可以调用下面函数：

pthread_mutex_trylock()

如果此时互斥量没有被上锁，那么pthread_mutex_trylock()将会返回0，并会对该互斥量上锁。如果互斥量已经被上锁，那么会立刻返回EBUSY。

上面谈到的是使用互斥量。如果碰到下面这种情况，该怎么办了？

还是上面程序中提到的工作链表。此时必然有一个生产者线程，用于往链表里添加节点。如果这一段时间没有工作，那么工作线程将会不停的调用lock,unlock操作。而这样的操作毫无疑义。

在这里系统给我们提供了另外一种同步机制，信号灯,Semaphore。

信号灯其实就是一个计数器，也是一个整数。每一次调用wait操作将会使semaphore值减一，而如果semaphore值已经为0，则wait操作将会阻塞。每一次调用post操作将会使semaphore值加一。将这些操作用到上面的问题中。工作线程每一次调用wait操作，如果此时链表中没有节点，则工作线程将会阻塞，直到链表中有节点。生产者线程在每次往链表中添加节点后调用post操作，信号灯值会加一。这样阻塞的工作线程就会停止阻塞，继续往下执行。

信号灯的类型为sem_t。在声明后必须调用sem_init()。需要传递两个参数，第一个参数就是你之前声明的sem_t变量，第二个必须为0。当你不再需要信号灯时，你必须调用sem_destroy()来释放资源。

等待信号灯的操作为sem_wait()。投递一个信号的操作为sem_wait()。和互斥量一样，等待信号灯也有一个非阻塞的操作，sem_trywait()。该操作在没有信号灯的时候返回EAGAIN。

下面是一个结合了互斥量和信号灯的例子：

#include <malloc.h> #include <pthread.h> #include <semaphore.h> struct job { /* Link field for linked list. */ struct job* next; /* Other fields describing work to be done... */ }; /* A linked list of pending jobs. */ struct job* job_queue; /* A mutex protecting job_queue. */ pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER; /* A semaphore counting the number of jobs in the queue. */ sem_t job_queue_count; /* Perform one-time initialization of the job queue. */ void initialize_job_queue () { /* The queue is initially empty. */ job_queue = NULL; /* Initialize the semaphore which counts jobs in the queue. Its initial value should be zero. */ sem_init (&job_queue_count, 0, 0); } /* Process queued jobs until the queue is empty. */ void* thread_function (void* arg) { while (1) { struct job* next_job; /* Wait on the job queue semaphore. If its value is positive, indicating that the queue is not empty, decrement the count by 1. If the queue is empty, block until a new job is enqueued. */ sem_wait (&job_queue_count); /* Lock the mutex on the job queue. */ pthread_mutex_lock (&job_queue_mutex); /* Because of the semaphore, we know the queue is not empty. Get the next available job. */ next_job = job_queue; /* Remove this job from the list. */ job_queue = job_queue->next; /* Unlock the mutex on the job queue because we’re done with the queue for now. */ pthread_mutex_unlock (&job_queue_mutex); /* Carry out the work. */ process_job (next_job); /* Clean up. */ free (next_job); } return NULL; } /* Add a new job to the front of the job queue. */ void enqueue_job (/* Pass job-specific data here... */) { struct job* new_job; /* Allocate a new job object. */ new_job = (struct job*) malloc (sizeof (struct job)); /* Set the other fields of the job struct here... */ /* Lock the mutex on the job queue before accessing it. */ pthread_mutex_lock (&job_queue_mutex); /* Place the new job at the head of the queue. */ new_job->next = job_queue; job_queue = new_job; /* Post to the semaphore to indicate that another job is available. If threads are blocked, waiting on the semaphore, one will become unblocked so it can process the job. */ sem_post (&job_queue_count); /* Unlock the job queue mutex. */ pthread_mutex_unlock (&job_queue_mutex); }

下面说一下第三种同步机制—条件变量。

如果现在在等待一个信号。如果该信号被设置，则继续运行。如果没有条件变量，我们将会不停的去查询该信号是否被设置，这样就会浪费大量的cpu。而通过使用条件变量，我们就可以将等待信号的线程阻塞，直到有信号的时候再去唤醒它。

条件变量的类型是pthread_cond_t。

下面简单说一下如何使用条件变量。

l         声明pthread_cond_t变量后，调用pthread_cond_init()函数，第一个参数为之前声明的变量。第二个参数在Linux中不起作用。

l         声明一个pthread_mutex_t变量，并调用pthread_mutex_init()初始化。

l         调用pthread_cond_signal()，发出信号。如果此时有线程在等待该信号，那么该线程将会唤醒。如果没有，该信号就会别忽略。

l         如果想唤醒所有等待该信号的线程，调用pthread_cond_broadcast()。

l         调用pthread_cond_wait()等待信号。如果没有信号，线程将会阻塞，直到有信号。该函数的第一个参数是条件变量，第二个参数是一个mutex。在调用该函数之前必须先获得互斥量。如果线程阻塞，互斥量将立刻会被释放。

下面给出一个简单的使用例子。

#include <pthread.h> #include <stdio.h> pthread_mutex_t mutex; pthread_cond_t cond; int flag; void init() { pthread_mutex_init(&mutex,NULL); pthread_cond_init(&cond,NULL); flag=0; } void * Thread_Function(void * arg) { //loop infinitely while(1) {       pthread_mutex_lock(&mutex);       while(!flag)            pthread_cond_wait(&cond,&mutex);       pthread_mutex_unlock(&mutex);       do_some_work(); } } void SetFlag() {       pthread_mutex_lock(&mutex);       flag=1;       pthread_cond_signal(&cond);       pthread_mutex_unlock(&mutex); }