码迷,mamicode.com
首页 > 编程语言 > 详细

linux c++ 多线程 【三】

时间:2015-08-20 01:15:19      阅读:328      评论:0      收藏:0      [点我收藏+]

标签:

今天得空继续扫了一下(https://computing.llnl.gov/tutorials/pthreads/这次没有用c++,直接参考的tutorial中的c语言实现)pthread中提供的另一种线程同步的方法:condition variables

既然已经有了mutex,为什么还要有condition variables这样的技术手段呢

原文的阐述是:“While mutexes implement synchronization by controlling thread access to data, condition variables allow threads to synchronize based upon the actual value of data.”

按照我自己的理解就是:

1)mutex的作用仅限于是否允许某个子线程去访问、修改某个内存变量,以此做到同步;提供的synchronize逻辑判断仅限于:can or cannot

2)condition variables的作用比单纯mutex要强一些,可以与mutex联合使用;提供的synchronize机制可以是:if  condition then do work

上述的理解,也是我在实现过一个demo之后得出的,下面阐述一下simple demo。

考虑这样一个问题:

1)有一个全局的计数变量int count,各个线程均可以访问

2)有两个子线程对count进行累加操作

3)另外还有一个监控子线程,对于count的值是敏感的:当count累加到某个临界值的时候,触发这个子线程完成任务

代码如下:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define NUM_THREADS 3
#define TCOUNT 10
#define COUNT_LIMIT 12

int count = 0;
int thread_id[3] = {0,1,2};

pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;

void *inc_count(void *t)
{
    int i;
    long my_id = (long)t;

    for (i=0; i<TCOUNT; i++){
        pthread_mutex_lock(&count_mutex);
        count++;
        if ( count==COUNT_LIMIT )
        {
            pthread_cond_signal(&count_threshold_cv);
            printf("inc_count(): thread %ld, count = %d Threshold reached \n", my_id, count );
        }
        printf("inc_count() : thread %ld, count = %d, unlocking mutex \n", my_id, count);
        pthread_mutex_unlock(&count_mutex);
        sleep(1);
    }
    pthread_exit((void *) 0);
}

void *watch_count(void *t)
{
    long my_id = (long)t;
    printf("Starting watch_count(): thread %ld\n", my_id);

    pthread_mutex_lock(&count_mutex);
    while (count<COUNT_LIMIT)
    {
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf("watch_count(): thread %ld Condition signale received.\n", my_id);
        count += 125;
        printf("watch_count(): thread %ld count now = %d.\n",my_id, count);
    }
    pthread_mutex_unlock(&count_mutex);
    pthread_exit((void *) 0);
}

int main(int argc, char *argv[])
{
    int i, rc;
    long t1=1, t2=2, t3=3;
    pthread_t threads[3];
    pthread_attr_t attr;

    pthread_mutex_init(&count_mutex, NULL);
    pthread_cond_init(&count_threshold_cv, NULL);

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
    pthread_create(&threads[0], &attr, watch_count, (void *)t1);
    pthread_create(&threads[1], &attr, inc_count, (void *)t2);
    pthread_create(&threads[2], &attr, inc_count, (void *)t3);

    for (i=0; i<NUM_THREADS; ++i ){
        pthread_join(threads[i], NULL);
    }

    printf("Main(): Waited on %d threads. Done. \n", NUM_THREADS);

    pthread_attr_destroy(&attr);
    pthread_mutex_destroy(&count_mutex);
    pthread_cond_destroy(&count_threshold_cv);
    pthread_exit((void *)0);
}

先给输出结果,再解释这段代码是怎么实现上述的问题的:

技术分享

两种子线程:

1)void *inc_count(void *t)实现了给全局变量count的累加计数功能

2)void *watch_count(void *t)实现了监控全局变量count的值并触发任务的功能

下面记录我自己分析每个子线程的实现逻辑的思路顺序:

1)watch_count对count进行监控:

 1 void *watch_count(void *t)
 2 {
 3     long my_id = (long)t;
 4     printf("Starting watch_count(): thread %ld\n", my_id);
 5 
 6     pthread_mutex_lock(&count_mutex);
 7     while (count<COUNT_LIMIT)
 8     {
 9         pthread_cond_wait(&count_threshold_cv, &count_mutex);
10         printf("watch_count(): thread %ld Condition signale received.\n", my_id);
11         count += 125;
12         printf("watch_count(): thread %ld count now = %d.\n",my_id, count);
13     }
14     pthread_mutex_unlock(&count_mutex);
15     pthread_exit((void *) 0);
16 }

a. 为什么line 6要先对count_mutex上锁呢?

  因为,当watch_count在判断count的值的时候,必须“独揽”对count的操作权利;如果正判断count的时候,count被其他线程改变了或者怎样,逻辑就很可能是错误的(这一点在这个系列的前几篇日志中说明了

b. “pthread_cond_wait(&count_threshold_cv, &count_mutex);”的作用是什么?

  首先解释下参数:pthread_cond_t count_threashold_cv正是这一节提到的条件变量;count_mutex是用于全局变量count的同步锁

  这个语句相当于做了如下两件件事情:

    b1. 先阻塞当前线程

    b2. 判断count_threshold_cv这个条件变量是否被激活:

       b21. 如果没被激活,自动放开对count_mutex的锁(这个解锁是针对line 6对count_mutex上的锁);当前线程继续保持被阻塞状态

       b22. 如果被激活,唤醒count_mutex的锁;当前的线程不被阻塞,继续往下执行(由于line 6一直锁着当前线程,则需要线程执行完毕前对count_mutex解锁) 

c. 读完上述的代码,马上产生两个疑问:

    c1. count_threshold_cv的初始状态到底激活没激活是谁管的?

      是main()函数中的“pthread_cond_init(&count_threshold_cv, NULL);”语句,初始化count_threshold_cv没激活的。

    c2. count_threshold_cv的激活是谁管的呢?

      这就要再分析另一个子线程函数inc_count了

2)inc_count子线程对count进行累加操作 & 对条件变量count_threshold_cv进行激活操作

 1 void *inc_count(void *t)
 2 {
 3     int i;
 4     long my_id = (long)t;
 5 
 6     for (i=0; i<TCOUNT; i++){
 7         pthread_mutex_lock(&count_mutex);
 8         count++;
 9         if ( count==COUNT_LIMIT )
10         {
11             pthread_cond_signal(&count_threshold_cv);
12             printf("inc_count(): thread %ld, count = %d Threshold reached \n", my_id, count );
13         }
14         printf("inc_count() : thread %ld, count = %d, unlocking mutex \n", my_id, count);
15         pthread_mutex_unlock(&count_mutex);
16         sleep(1);
17     }
18     pthread_exit((void *) 0);
19 }

这个函数比较直观:

1)Loop中每次都对count加1(当然了,对count进行操作时一定要对count_mutex加锁,line 7的语句

2)对count的值进行判断:

    a. 如果count不等于临界值:do some work,并对count_mutex进行解锁;然后再sleep一下(目的是人工给其他线程获得count_mutex控制权的机会

    b. 如果count等于临界值:

      b1. 激活条件变量count_threshold_cv

      b2. 唤醒由于等待count_threshold_cv而被阻塞的线程(这个demo里只有一个等着的线程,如果多个线程都等待count_threshold_cv呢?这个过后值得思考一下

  b2里有一个细节问题:当count_threshold_cv被激活后,watch_count是马上执行呢?还是等着激活count_threshold_cv的这个线程执行执行完再被“真正”唤醒呢?用结果说话:

技术分享

  显然,即便是count_threshold_cv被激活之后,watch_count也没有马上执行;而是等着inc_count中的count_mutex被解锁后,再执行被激唤醒的watch_count线程;watch_count线程被唤醒的同时,watch_count线程又重新夺回了count_mutex的占有权。

上面的demo已经大概解释说明了condition variables是怎么使用的,有几个细节还应该扣一扣:

细节一

  这里其实还有地方没十分确定:如上图,当count_threshold_cv被thread3激活了,并且thread3线程已经对count_mutex执行unlocking了,这个时候会不会存在thread1(thread1是watch_count线程)和thread2(thread2是另一个inc_count线程)同时竞争count_mutex的情况呢?根据输出的结果来看,此时可能不存在thread1和thread2竞争的情况,操作系统赋予了被唤醒的thread1对count_mutex的优先上锁权。

细节二

  如果调用pthread_cond_wait的线程里面,没有对count_mutex的限制,那么运行的结果如何呢?我稍微修了一下代码,增加了一个全局的pthread_mutex_t test,并在main中将其初始化,并修改inc_count函数和watch_count函数如下(红色是修改的部分):

void *inc_count(void *t)
{
    int i;
    long my_id = (long)t;

    for (i=0; i<TCOUNT; i++){
        pthread_mutex_lock(&count_mutex);
        count++;
        if ( count==COUNT_LIMIT )
        {
            pthread_cond_signal(&count_threshold_cv);
            sleep(1);
            printf("inc_count(): thread %ld, count = %d Threshold reached \n", my_id, count );
        }
        printf("inc_count() : thread %ld, count = %d, unlocking mutex \n", my_id, count);
        pthread_mutex_unlock(&count_mutex);
        sleep(1);
    }
    pthread_exit((void *) 0);
}

void *watch_count(void *t)
{
    long my_id = (long)t;
    printf("Starting watch_count(): thread %ld\n", my_id);

    pthread_mutex_lock(&test);
    int i=0;
    while (i<1)
    {
        pthread_cond_wait(&count_threshold_cv, &test);
        printf("watch_count(): thread %ld Condition signale received.\n", my_id);
        count += 125;
        printf("watch_count(): thread %ld count now = %d.\n",my_id, count);
        i++;
    }
    pthread_mutex_unlock(&test);
    pthread_exit((void *) 0);
}

运行结果如下:

技术分享

通过这个运行结果,可以看到:一旦pthread_cond_signal之后,由于没有count_mutex的上锁限制,watch_count线程立刻执行了(这里在inc_count函数中加了sleep(1)就是故意等着,看watch_count有没有立即不受阻塞执行)。因此,从反面再次验证了,调用pthread_cond_signal的线程仅仅是发送一个激活watch_count线程的信号;如果watch_count中受到了count_mutex的限制,那么还是要等到inc_count中对count_mutex解锁后才会被真正激活。

下面这两个连接,对pthread_cond_wait()和pthread_cond_signal()有比较详细的解释

https://computing.llnl.gov/tutorials/pthreads/man/pthread_cond_wait.txt

https://computing.llnl.gov/tutorials/pthreads/man/pthread_cond_signal.txt

但实际工作中,还得去试验一下代码运行的平台系统,对pthread是怎样一种具体的实现策略。

   

linux c++ 多线程 【三】

标签:

原文地址:http://www.cnblogs.com/xbf9xbf/p/4743701.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!