Linux操作系统下的多线程编程详细解析----条件变量

ゝ一世哀愁。 2022-06-04 05:49 207阅读 0赞

条件变量通过**允许线程阻塞**和**等待另一个线程发送信号**的方法，弥补了互斥锁（Mutex）的不足.

# 1.初始化条件变量pthread\_cond\_init #

\#include <pthread.h>

int pthread\_cond\_init(pthread\_cond\_t \*cv ,   const pthread\_condattr\_t \*cattr);

返回值：函数成功返回0；任何其他返回值都表示错误

初始化一个条件变量。当参数cattr为空指针时，函数创建的是一个缺省的条件变量。否则条件变量的属性将由cattr中的属性值来决定。调用 pthread\_cond\_init函数时，参数cattr为空指针等价于cattr中的属性为缺省属性，只是前者不需要cattr所占用的内存开销。这个函数返回时，条件变量被存放在参数cv指向的内存中。

可以用宏PTHREAD\_COND\_INITIALIZER来初始化静态定义的条件变量，使其具有缺省属性。这和用pthread\_cond\_init函数动态分配的效果是一样的。初始化时不进行错误检查。如：

pthread\_cond\_t cv = PTHREAD\_COND\_INITIALIZER;

不能由多个线程同时初始化一个条件变量。当需要重新初始化或释放一个条件变量时，应用程序必须保证这个条件变量未被使用。

# 2.阻塞在条件变量上pthread\_cond\_wait #

\#include <pthread.h>

int pthread\_cond\_wait(pthread\_cond\_t \*cv,

pthread\_mutex\_t \*mutex);

返回值：函数成功返回0；任何其他返回值都表示错误

函数将解锁mutex参数指向的互斥锁，并使当前线程阻塞在cv参数指向的条件变量上。

**被阻塞的线程可以被pthread\_cond\_signal函数，pthread\_cond\_broadcast函数唤醒，也可能在被信号中断后被唤醒。**

**pthread\_cond\_wait函数的返回并不意味着条件的值一定发生了变化，必须重新检查条件的值**。

pthread\_cond\_wait函数返回时，相应的互斥锁将被当前线程锁定，即使是函数出错返回。

一般一个条件表达式都是在一个互斥锁的保护下被检查。当条件表达式未被满足时，线程将仍然阻塞在这个条件变量上。当另一个线程改变了条件的值并向条件变量发出信号时，等待在这个条件变量上的一个线程或所有线程被唤醒，接着都试图再次占有相应的互斥锁。

阻塞在条件变量上的线程被唤醒以后，直到pthread\_cond\_wait()函数返回之前条件的值都有可能发生变化。所以函数返回以后，在锁定相应的互斥锁之前，必须重新测试条件值。最好的测试方法是循环调用pthread\_cond\_wait函数，并把满足条件的表达式置为循环的终止条件。如：

pthread\_mutex\_lock();

while (condition\_is\_false)

pthread\_cond\_wait();

pthread\_mutex\_unlock();

阻塞在同一个条件变量上的不同线程被释放的次序是不一定的。

注意：pthread\_cond\_wait()函数是退出点，如果在调用这个函数时，已有一个挂起的退出请求，且线程允许退出，这个线程将被终止并开始执行善后处理函数，而这时和条件变量相关的互斥锁仍将处在锁定状态。

# 3.解除在条件变量上的阻塞pthread\_cond\_signal #

\#include <pthread.h>

int pthread\_cond\_signal(pthread\_cond\_t \*cv);

返回值：函数成功返回0；任何其他返回值都表示错误

函数被用来释放被阻塞在指定条件变量上的一个线程。

必须在互斥锁的保护下使用相应的条件变量。否则对条件变量的解锁有可能发生在锁定条件变量之前，从而造成死锁。

唤醒阻塞在条件变量上的所有线程的顺序由调度策略决定，如果线程的调度策略是SCHED\_OTHER类型的，系统将根据线程的优先级唤醒线程。

如果没有线程被阻塞在条件变量上，那么调用pthread\_cond\_signal()将没有作用。

# 4.阻塞直到指定时间pthread\_cond\_timedwait #

\#include <pthread.h>

\#include <time.h>

int pthread\_cond\_timedwait(pthread\_cond\_t \*cv,

pthread\_mutex\_t \*mp, const structtimespec \* abstime);

返回值：函数成功返回0；任何其他返回值都表示错误

函数到了一定的时间，即使条件未发生也会解除阻塞。这个时间由参数abstime指定。函数返回时，相应的互斥锁往往是锁定的，即使是函数出错返回。

注意：pthread\_cond\_timedwait函数也是退出点。

超时时间参数是指一天中的某个时刻。使用举例：

pthread\_timestruc\_t to;

to.tv\_sec = time(NULL) + TIMEOUT;

to.tv\_nsec = 0;

超时返回的错误码是ETIMEDOUT。

# 5.释放阻塞的所有线程pthread\_cond\_broadcast #

\#include <pthread.h>

int pthread\_cond\_broadcast(pthread\_cond\_t \*cv);

返回值：函数成功返回0；任何其他返回值都表示错误

函数唤醒所有被pthread\_cond\_wait函数阻塞在某个条件变量上的线程，参数cv被用来指定这个条件变量。当没有线程阻塞在这个条件变量上时，pthread\_cond\_broadcast函数无效。

由于pthread\_cond\_broadcast函数唤醒所有阻塞在某个条件变量上的线程，这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用pthread\_cond\_broadcast函数。

# 6.释放条件变量pthread\_cond\_destroy #

\#include <pthread.h>

int pthread\_cond\_destroy(pthread\_cond\_t \*cv);

返回值：函数成功返回0；任何其他返回值都表示错误

释放条件变量。

注意：条件变量占用的空间并未被释放。

# 7.唤醒丢失问题 #

在线程未获得相应的互斥锁时调用pthread\_cond\_signal或pthread\_cond\_broadcast函数可能会引起唤醒丢失问题。

唤醒丢失往往会在下面的情况下发生：

1.  一个线程调用pthread\_cond\_signal或pthread\_cond\_broadcast函数；
2.  另一个线程正处在测试条件变量和调用pthread\_cond\_wait函数之间；
3.  没有线程正在处在阻塞等待的状态下。

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <pthread.h>
    
    int i = 0;
    
    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    
    void* thread1(void *arg)
    {
        for (;;)
        {
            printf("thread1 loop...\n");
            pthread_mutex_lock(&lock);
            printf("thread1 wait cond...\n");
            pthread_cond_wait(&cond, &lock);
            printf("thread1 work...%d\n", i);
            pthread_mutex_unlock(&lock);
        }
    
        return (void*)0;
    }
    
    void* thread2(void *arg)
    {
        sleep(1);
    
        while (++i < 100)
        {
            printf("thread2 loop...\n");
    
            if (i % 10 == 0)
            {
                pthread_mutex_lock(&lock);
                pthread_cond_signal(&cond);
    	    printf("thread2 signal cond...\n");
                pthread_mutex_unlock(&lock);
                sleep(1);
            }
    	sleep(1);
        }
    
        printf("thread2 exit\n");
        return (void*)0;
    }
    
    int main(void)
    {
        pthread_t ntid1;
        pthread_t ntid2;
    
        pthread_create(&ntid1, NULL, thread1, NULL);
        pthread_create(&ntid2, NULL, thread2, NULL);
    
        pthread_join(ntid1, NULL);
        pthread_join(ntid2, NULL);
    
        pthread_mutex_destroy(&lock);
        pthread_cond_destroy(&cond);
    
        return EXIT_SUCCESS;
    }

运行结果如下（部分）：

thread1 loop...
    thread1 wait cond...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 signal cond...
    thread1 work...10
    thread1 loop...
    thread1 wait cond...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 signal cond...
    thread1 work...20
    thread1 loop...
    thread1 wait cond...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 signal cond...
    thread1 work...30
    thread1 loop...
    thread1 wait cond...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...
    thread2 loop...

线程1先运行，到线程1阻塞（pthread\_cond\_wait(&cond, &lock);），然后线程1一直在这里等待，直到  线程2发送信号（pthread\_cond\_signal(&cond);），线程1才停止阻塞，继续运行。然后如此循环。

参考：

https://www.cnblogs.com/jiu0821/p/6424951.html

http://blog.csdn.net/jimmy\_w/article/details/38568425