你好,游客 登录 注册 搜索
背景:
阅读新闻

Linux多线程-互斥&条件变量与同步

[日期:2016-07-20] 来源:Linux社区  作者:lang5230 [字体: ]

多线程代码问题描述

我们都知道,进程是操作系统对运行程序资源分配的基本单位,而线程是程序逻辑,调用的基本单位。在多线程的程序中,多个线程共享临界区资源,那么就会有问题:

比如

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

int g_val = 10;
void * test1(void* args)
{
    g_val = 20;
    printf("in %s: g_val = %d\n",__func__, g_val);
}
void * test2(void* args)
{
    sleep(1);
    printf("in %s: g_val = %d\n",__func__,g_val);
}
int main(int argc, char const *argv[])
{
    pthread_t id1,id2;
    pthread_create(&id1,NULL,test1,NULL);
    pthread_create(&id2,NULL,test2,NULL);
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    return 0;
} 

由次我们可以看到,线程1修改了全局变量,而线程2中页跟着改变了。

那么,对于这个问题进行放大,我们就会找到多线程存在的问题。如下

#include <stdio.h>
#include <pthread.h>
// pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int g_val = 0;
void* add(void *argv)
{
    for(int i = 0 ; i < 5000; ++i)
    {
        // g_val++;
        // pthread_mutex_lock(&lock);
        int tmp = g_val;
        g_val = tmp+1;
        // pthread_mutex_unlock(&lock);
    }
}

int main(int argc, char const *argv[])
{
    pthread_t id1,id2;

    pthread_create(&id1,NULL,add,NULL);
    pthread_create(&id2,NULL,add,NULL);

    pthread_join(id1,NULL);
    pthread_join(id2,NULL);

    printf("%d\n",g_val);
    return 0;
}

在上面代码中,我们执行两个线程分别对全局变量累加5000次,但是得到的结果却是不确定的。这是因为,在多线程程序中,线程调度使得线程间进行切换执行,如果当线程1将数据从内存读入cpu正在准备累加时,调度器切换线程2执行,此时,线程2获取的值是未累加的。那么,当两个线程都执行完本次累加后,实际值只增加了1。所以就会产生多次执行,结果不确定性。

注:代码中没有直接g_val++,而选择了tmp过度就是为了产生非原子操作,让调度过程处于累加未完时。

那么解决这个问题,就需要互斥操作了。

我们首先来谈互斥量mutex

通过互斥量实现线程锁,在每个线程累加之前,进行临界资源的锁操作,在结束时解锁,那么就能保证目标的实现了。

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int g_val = 0;
void* add(void *argv)
{
    for(int i = 0 ; i < 5000; ++i)
    {
        // g_val++;
        pthread_mutex_lock(&lock);
        int tmp = g_val;
        g_val = tmp+1;
        pthread_mutex_unlock(&lock);
    }
}

int main(int argc, char const *argv[])
{
    pthread_t id1,id2;

    pthread_create(&id1,NULL,add,NULL);
    pthread_create(&id2,NULL,add,NULL);

    pthread_join(id1,NULL);
    pthread_join(id2,NULL);

    printf("%d\n",g_val);
    return 0;
}

关于互斥锁的实现,在linux中实现如下

条件变量

问题场景描述

假设我们现在需要做一个生产者消费者模型,生产者对带有头节点的链表头插方式push_front生产数据,消费者调用pop_front消费数据.而生产者可能动作比较慢,这时就会有问题。

生产者生产一个数据时间,消费者可能迫切需求。因此,一直轮寻申请锁资源,以便进行消费。所以就会产生多次不必的锁资源申请释放动作。影响系统性能。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
typedef struct node 
{
    int _data;
    struct node *_next;
}node_t,* node_p,**node_pp;

node_p head = NULL;

node_p alloc_node(int data)
{
    node_p ret = (node_p)malloc(sizeof(node_t));
    ret->_data = data;
    ret->_next = NULL;
    return ret;
}

void init(node_pp phead)
{
    *phead = alloc_node(0);
}

void push_front(node_p head,int data)
{
    node_p tmp = alloc_node(data);
    tmp->_next = head->_next;
    head->_next = tmp;
}

void pop_front(node_p head, int * pdata)
{
    if(head->_next!=NULL)
    {
        node_p tmp = head->_next;
        head->_next = tmp->_next;

        *pdata = tmp->_data;
        free(tmp);        
    }
}

void show(node_p head)
{
    node_p cur = head->_next;
    while(cur)
    {
        printf("%d->", cur->_data);
        cur = cur->_next;
    }
    printf("\n");
}

//消费者
void * consumer(void *argv)
{
    int data;
    while(1)
    {
        pthread_mutex_lock(&lock);
        // while(head->_next==NULL)
        if(head->_next==NULL)
        {
            printf("producter is not ready\n");
            // pthread_cond_wait(&cond,&lock);
            // break;
        }
        else{
        printf("producter is ready...\n");
        pop_front(head,&data);
        printf("%s  data = %d \n",__func__, data);
        }
        pthread_mutex_unlock(&lock);

        sleep(1);
    }
}

void * producter(void * argv)
{
    int data = rand()%1234;
    while(1)
    {
        sleep(4);
        pthread_mutex_lock(&lock);
        push_front(head,data);
        printf("%s data :: %d\n",__func__, data);
        pthread_mutex_unlock(&lock);
        // pthread_cond_signal(&cond);
    }
}

int main(int argc, char const *argv[])
{
    init(&head);

    pthread_t id1,id2;
    
    pthread_create(&id1,NULL,consumer,NULL);
    pthread_create(&id2,NULL,producter,NULL);

    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
}

由上,我们发现。生产者生叉一个数据之后,消费者总是会多次进行锁资源申请并尝试消费数据。那么,解决这一问题的方案就是:条件变量。

具体实现如下:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
typedef struct node 
{
    int _data;
    struct node *_next;
}node_t,* node_p,**node_pp;

node_p head = NULL;

node_p alloc_node(int data)
{
    node_p ret = (node_p)malloc(sizeof(node_t));
    ret->_data = data;
    ret->_next = NULL;
    return ret;
}

void init(node_pp phead)
{
    *phead = alloc_node(0);
}

void push_front(node_p head,int data)
{
    node_p tmp = alloc_node(data);
    tmp->_next = head->_next;
    head->_next = tmp;
}

void pop_front(node_p head, int * pdata)
{
    if(head->_next!=NULL)
    {
        node_p tmp = head->_next;
        head->_next = tmp->_next;

        *pdata = tmp->_data;
        free(tmp);        
    }
}

void show(node_p head)
{
    node_p cur = head->_next;
    while(cur)
    {
        printf("%d->", cur->_data);
        cur = cur->_next;
    }
    printf("\n");
}

//消费者
void * consumer(void *argv)
{
    int data;
    while(1)
    {
        pthread_mutex_lock(&lock);
        while(head->_next==NULL)
        // if(head->_next==NULL)
        {
            printf("producter is not ready\n\n");
            pthread_cond_wait(&cond,&lock);
            break;
        }
        // else{
        // printf("producter is ready...\n");
        pop_front(head,&data);
        printf("%s  data = %d \n",__func__, data);
        // }
        pthread_mutex_unlock(&lock);

        sleep(1);
    }
}

void * producter(void * argv)
{
    int data = rand()%1234;
    while(1)
    {
        sleep(4);
        pthread_mutex_lock(&lock);
        push_front(head,data);
        printf("%s data :: %d\n",__func__, data);
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond); //条件变量v操作
    }
}

int main(int argc, char const *argv[])
{
    init(&head);

    pthread_t id1,id2;
    
    pthread_create(&id1,NULL,consumer,NULL);
    pthread_create(&id2,NULL,producter,NULL);

    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
}

由图可以看出,这下我们的消费者不再进行过多次没必要的轮寻访问,当生产者生产数据时,告诉消费者可以进行消费了,那么消费者进行消费。

其实这也就是著名的:好莱坞原则---不要打电话给我们,我们会通知你。

eg,在面试笔试中,我们不需要过度的紧张是否被录用,只需要在做到最大努力之后等着招聘方通知就好。

注:一个Condition Variable总是和一个Mutex搭配使用的。一个线程可以调用
pthread_cond_wait在一一个Condition Variable上阻塞等待,这个函数做以下三步操作:
1. 释放Mutex
2. 阻塞等待
3. 当被唤醒时,重新获得Mutex并返回

本文永久更新链接地址http://www.linuxidc.com/Linux/2016-07/133367.htm

linux
相关资讯       Linux多线程  条件变量  同步  互斥 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款