pthread_cond_wait()用法分析

来源：互联网发布：慢镜头回放软件编辑：程序博客网时间：2024/05/22 09:15

一。http://blog.csdn.net/hairetz/article/details/4535920

很久没看APUE，今天一位朋友问道关于一个mutex的问题，又翻到了以前讨论过的东西，为了不让自己忘记，把曾经的东西总结一下。
先大体看下网上很多地方都有的关于pthread_cond_wait()的说明：

条件变量

条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

1．创建和注销

条件变量和互斥锁一样，都有静态动态两种创建方式，静态方式使用PTHREAD_COND_INITIALIZER常量，如下：
pthread_cond_t cond=PTHREAD_COND_INITIALIZER

动态方式调用pthread_cond_init()函数，API定义如下：
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

尽管POSIX标准中为条件变量定义了属性，但在LinuxThreads中没有实现，因此cond_attr值通常为NULL，且被忽略。

注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下：
int pthread_cond_destroy(pthread_cond_t *cond)

2．等待和激发

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)



等待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。

激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。

现在来看一段典型的应用：看注释即可。

[cpp] view plaincopy
#include <pthread.h>  
#include <unistd.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) {  
    pthread_mutex_lock(&mtx);           //这个mutex主要是用来保证pthread_cond_wait的并发性  
    while (head == NULL)   {               //这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。这个时候，应该让线程继续进入pthread_cond_wait  
        pthread_cond_wait(&cond, &mtx);         // pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，然后阻塞在等待对列里休眠，直到再次被唤醒（大多数情况下是等待的条件成立而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源  
                                                //用这个流程是比较清楚的/*block-->unlock-->wait() return-->lock*/  
    }  
        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);   //子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大  
    /*[tx6-main]*/  
    for (i = 0; i < 10; i++) {  
        p = 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(tid);             //关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。关于取消点的信息，有兴趣可以google,这里不多说了  
    pthread_join(tid, NULL);  
    printf("All done -- exiting/n");  
    return 0;  
}  

二。http://www.cnblogs.com/leaven/archive/2010/06/03/1750973.html

最近在温习pthread的时候，忽然发现以前对pthread_cond_wait的了解太肤浅了。昨晚在看《Programming With POSIX Threads》的时候，看到了pthread_cond_wait的通常使用方法：

pthread_mutex_lock();

while(condition_is_false)

pthread_cond_wait();

pthread_mutex_unlock();

为什么在pthread_cond_wait()前要加一个while循环来判断条件是否为假呢？

APUE中写道:

传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作是原子操作。

线程释放互斥量，等待其他线程发给该条件变量的信号（唤醒一个等待者）或广播该条件变量（唤醒所有等待者）。当等待条件变量时，互斥量必须始终为释放的，这样其他线程才有机会锁住互斥量，修改条件变量。当线程从条件变量等待中醒来时，它重新继续锁住互斥量，对临界资源进行处理。

条件变量的作用是发信号，而不是互斥。

wait前检查

对于多线程程序，不能够用常规串行的思路来思考它们，因为它们是完全异步的，会出现很多临界情况。比如：pthread_cond_signal的时间早于pthread_cond_wait的时间，这样pthread_cond_wait就会一直等下去，漏掉了之前的条件变化。

对于这种情况，解决的方法是在锁住互斥量之后和等待条件变量之前，检查条件变量是否已经发生变化。

if(condition_is_false)

pthread_cond_wait();

这样在等待条件变量前检查一下条件变量的值，如果条件变量已经发生了变化，那么就没有必要进行等待了，可以直接进行处理。这种方法在并发系统中比较常见，例如之前PACKET_MMAP中poll的竞争条件的解决方法。

-----------------------------------------------------------------------

忽然想起了设计模式中的单件模式的"双重检查加锁"：

Singleton *getInstance()

{

if(ptr==NULL)

{

LOCK();

if(ptr==NULL)

{

ptr = new Singleton();

}

UNLOCK();

}

return ptr;

}

这样只有在第一次的时候会进行锁(应该是第一轮，如果刚开始有多个线程进入了最上层的ptr==NULL代码块，就会有多次锁，只不过之后就不会锁了)，之后就不会锁了。

pthread_once()的实现也是基于单件模式的。

pthread_once函数首先检查控制变量，以判断是否已经完成初始化。如果完成，pthread_once简单的返回；否则，pthread_once调用初始化函数(没有参数)，并记录下初始化被完成。如果在一个线程初始化时，另外的线程调用pthread_once，则调用线程将等待，直到那个线程完成初始化后返回。换句话，当调用pthread_once成功返回时，调用者能够肯定所有的状态已经初始化完毕。

int

__pthread_once (once_control, init_routine)

pthread_once_t *once_control;

void (*init_routine) (void);

{

/* XXX Depending on whether the LOCK_IN_ONCE_T is defined use a

global lock variable or one which is part of the pthread_once_t

object. */

if (*once_control == PTHREAD_ONCE_INIT)

{

lll_lock (once_lock, LLL_PRIVATE);

/* XXX This implementation is not complete. It doesn't take

cancelation and fork into account. */

if (*once_control == PTHREAD_ONCE_INIT)

{

init_routine ();

*once_control = !PTHREAD_ONCE_INIT;

}

lll_unlock (once_lock, LLL_PRIVATE);

}

return 0;

}

-----------------------------------------------------------------------

pthread_cond_wait中的while()不仅仅在等待条件变量前检查条件变量，实际上在等待条件变量后也检查条件变量。pthread_cond_wait返回后，还需要检查条件变量，这是为什么呢？难道pthread_cond_wait不是pthread_cond_signal触发了某个condition导致的吗？

这个地方有些迷惑人，实际上pthread_cond_wait的返回不仅仅是pthread_cond_signal和pthread_cond_broadcast导致的，还会有一些假唤醒，也就是spurious wakeup。

何为假唤醒？顾名思义就是虚假的唤醒，与pthread_cond_signal和pthread_cond_broadcast的唤醒相对。那么什么情况下会导致假唤醒呢？可以阅读参考1。

signal

大致意思是：

在linux中，pthread_cond_wait底层是futex系统调用。在linux中，任何慢速的阻塞的系统调用当接收到信号的时候，就会返回-1，并且设置errno为EINTR。在系统调用返回前，用户程序注册的信号处理函数会被调用处理。

注:什么有样的系统调用会出现接收信号后发挥EINTR呢？

慢速阻塞的系统调用，有可能会永远阻塞下去的那种。当接收到信号的时候，认为是一个返回并执行其他代码的一个时机。

信号的处理也不简单，因为有些慢系统调用被信号中断后是会自动重启的，所以我们通常需要用siginterrupt(signo, 1)来关闭重启或者在用sigaction安装信号处理函数的时候取消SA_RESTART标志，之后就可以通过判断信号的返回值是否是-1和errno是否为EINTR来判断是否有信号抵达。

如果关闭了SA_RESTART的一些使用慢速系统调用的应用，一般都采用while()循环，检测到EINTR后就重新调用。

while(1)

{

int ret = syscall();

if(ret<0 && errno==EINTR)

continue;

else

break;

}

但是，对于futex这种方法不行，因为futex结束后，再重新运行的过程中，会出现一个时间窗口，其他线程可能会在这个时间窗口中进行pthread_cond_signal，这样，再进行pthread_cond_wait的时候就丢失了一次条件变量的变化。解决方法就是在pthread_cond_wait前检查条件变量，也就是

pthread_mutex_lock();

while(condition_is_false)

pthread_cond_wait();

pthread_mutex_unlock();

pthread_cond_broadcast

实际上，不仅仅信号会导致假唤醒，pthread_cond_broadcast也会导致假唤醒。加入条件变量上有多个线程在等待，pthread_cond_broadcast会唤醒所有的等待线程，而pthread_cond_signal只会唤醒其中一个等待线程。这样，pthread_cond_broadcast的情况也许要在pthread_cond_wait前使用while循环来检查条件变量。

参考：

http://vladimir_prus.blogspot.com/2005/07/spurious-wakeups.html

http://www.lambdacs.com/cpt/FAQ.html#Q94

http://groups.google.de/group/comp.programming.threads/msg/bb8299804652fdd7

http://www.win.tue.nl/~aeb/linux/lk/lk-4.html#ss4.5

http://blog.chinaunix.net/u/5251/showart_309061.html

0 0