POSIX多线程程序设计（第3章：同步）

最新推荐文章于 2021-03-08 01:22:18 发布
最新推荐文章于 2021-03-08 01:22:18 发布
阅读量568 收藏 2
点赞数
分类专栏： POSIX多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lincoln_2012/article/details/47979613
版权

    当多个线程对共享数据同时操作时，为了保证共享数据的一致性，需要同步线程的读写操作。

1互斥量

1.1函数

1创建和销毁互斥量

#include <pthread.h>

/*动态创建和销毁*/

int pthread_mutex_init(pthread_mutex_t * mutex, const pthread_mutexattr_t * attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

返回值：若成功返回0，否则返回错误编号

 

/*静态初始化，不需要销毁*/

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

2加锁和解锁互斥量

#include <pthread.h>

/*加锁,如果互斥量已上锁，调用线程将阻塞直到互斥量被解锁。*/

int pthread_mutex_lock(pthread_mutex_t *mutex);

/*解锁，不能解锁由其他线程锁住的互斥量*/

int pthread_mutex_unlock(pthread_mutex_t *mutex);

/*尝试加锁，如果互斥量已上锁，调用线程返回失败返回EBUSY而不会阻塞*/

int pthread_mutex_trylock(pthread_mutex_t *mutex);

返回值：若成功返回0，否则返回错误编号

1.2应用

/* errors.h*/
#ifndef __errors_h
#define __errors_h

#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef DEBUG
#define DPRINTF(arg) printf arg
#else
#define DPRINTF(arg)
#endif


#define err_abort(code,text) do{\
fprintf(stderr, "%s at \"%s\":%d: %s\n",\
text, __FILE__, __LINE__, strerror(code));\
abort();\
}while(0)

#define errno_abort(text) do {\
fprintf(stderr, "%s at \"%s\":%d: %s\n", \
text, __FILE__, __LINE__, strerror (errno)); \
abort();\
}while(0)

#endif
#include "errors.h"
#include <time.h>
#include <pthread.h>

typedef struct alarm_tag
{
    struct alarm_tag *link;
    time_t time;
    int    seconds;
    char message[64];
}alarm_t;

pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;/*互斥量*/
alarm_t *alarm_list = NULL;  /*全局变量，此处为需要同步的共享资源*/

void *alarm_thread(void *arg)
{
    alarm_t *alarm;
    int sleep_time;
    time_t now;
    int status;

    while (1)
    {
        /*加锁*/
        pthread_mutex_lock(&alarm_mutex);
   
        alarm = alarm_list;
        if (alarm == NULL)
        {
            /*闹钟链表为空，则休眠1s*/
            sleep_time = 1;
        }
        else
        {
            alarm_list = alarm->link;
            now = time(NULL);
            if (alarm->time <= now)
            {
                sleep_time = 0;
            }
            else
            {
                sleep_time = alarm->time - now;
            }
#ifdef DEBUG
            printf("[waiting: %d(%d)\"%s\"]\n", alarm->time, sleep_time, alarm->message);
#endif
        }

        /*解锁*/
        pthread_mutex_unlock(&alarm_mutex);
        
        if (sleep_time > 0)
        {
            /*开始休眠*/
            sleep(sleep_time);
        }
        else
        {
            /*将处理器交给另一个等待运行的线程，如果没有就绪的线程则立即返回*/
            sched_yield();
        }

        if (alarm != NULL)
        {
            printf("(%d) %s\n", alarm->seconds, alarm->message);
            free(alarm);
        }
    }
}


int main(int argc, char *argv[])
{
    int status;
    char line[128];
    alarm_t *alarm, **last, *next;
    pthread_t thread;

    status = pthread_create(&thread, NULL, alarm_thread, NULL);
    if (status != 0)
    {
        err_abort(status, "Create alarm thread");
    }

    while (1)
    {
        printf("Alarm> ");
        if (fgets(line, sizeof(line), stdin) == NULL)
            exit(0);

        if (strlen(line) <= 1)
            continue;

        alarm = (alarm_t *)malloc(sizeof(alarm_t));
        if (alarm == NULL)
        {
            errno_abort("allocate alarm");
        }
        
        if (sscanf(line, "%d %64[^\n]", &alarm->seconds, alarm->message) < 2)
        {
            fprintf(stderr, "Bad command\n");
            free(alarm);
        }
        else
        {
            /*加锁*/
            pthread_mutex_lock(&alarm_mutex);

            alarm->time = time(NULL) + alarm->seconds;
            last = &alarm_list;
            next = *last;
            while (next != NULL)
            {
                if (next->time >= alarm->time)
                {
                    alarm->link = next;
                    *last = alarm;
                    break;
                }
                last = &next->link;
                next = next->link;
            }

            if (next == NULL)
            {
                *last = alarm;
                alarm->link = NULL;
            }
#if DEBUG
            printf("[list: ");
            for (next = alarm_list; next != NULL; next = next->link)
                printf("%d(%d)[\"%s\"]", next->time, next->time - time(NULL), next->message);
            printf("]\n");

#endif
            /*解锁*/
            pthread_mutex_unlock(&alarm_mutex);
        }
    }
}

2条件变量

2.1函数

1条件变量初始化

#include <pthread.h>

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

int pthread_cond_destroy(pthread_cond_t *cond);

返回值：成功返回0，失败返回错误码

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;/*静态初始化*/

2等待条件变量

头文件

#include <pthread.h>

函数

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

参数

cond： 条件变量

mutex：互斥量，用来同步共享数据。

返回值

成功返回0，失败返回错误码。等待条件变量总是返回锁住的互斥量。

说明

在一个条件变量上等待会导致一下原子操作：

      释放相关互斥量，等待其他线程发给该条件变量信号或广播该条件变量。当等待条件变量时，互斥量必须始终为释放的，这样其他线程才有机会锁住互斥量，修改条件变量；当线程从条件变量等待中醒来时，它重新继续锁住互斥量。


头文件

#include <pthread.h>

函数

int pthread_cond_timedwait(pthread_cond_t *cond,

                                                  pthread_mutex_t *mutex,

                       struct timespec *timeout);

参数

cond：条件变量

mutex：互斥量

timeout：等待的时间值，用秒数tv_sec或分秒数tv_nsec来表示。

         struct timespec{

             time_t tv_sec;/*秒*/

            long tv_nsec;/*纳秒*/

         }; 

    timeout这个时间值是绝对数而不是相对数，例如等待3分钟，则需要把当前时间再加上3分钟再转换到timespec结构。

返回值

成功返回0，失败返回错误码

3唤醒等待条件变量的线程

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

返回值：成功返回0，失败返回错误码

2.2应用

#include "errors.h"
#include <time.h>
#include <pthread.h>

typedef struct alarm_tag
{
    struct alarm_tag *link;
    time_t time;
    int    seconds;
    char message[64];
}alarm_t;

pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t   alarm_cond = PTHREAD_COND_INITIALIZER;
alarm_t *alarm_list = NULL;
time_t current_alarm = 0;

void alarm_insert(alarm_t *alarm)
{
    int status;
    alarm_t **last, *next;

    last = &alarm_list;
    next = *last;
    while (next != NULL)
    {
        if (next->time >= alarm->time)
        {
            alarm->link = next;
            *last = alarm;
            break;
        }
        last = &next->link;
        next = next->link;
    }

    if (next == NULL)
    {
        *last = alarm;
        alarm->link = NULL;
    }

#if DEBUG
    printf("[list: ");
    for (next = alarm_list; next != NULL; next = next->link)
        printf("%d(%d)[\"%s\"]", next->time, next->time - time(NULL), next->message);
    printf("]\n");
#endif

    if (current_alarm ==0 || alarm->time < current_alarm)
    {
        current_alarm = alarm->time;
        status = pthread_cond_signal(&alarm_cond);
        if (status != 0)
        {
            err_abort(status, "signal cond");
        }
    }
}



void *alarm_thread(void *arg)
{
    alarm_t *alarm;
    struct timespec cond_time;
    time_t now;
    int status;
    int expired;

    /*加锁*/
    pthread_mutex_lock(&alarm_mutex);
    while (1)
    {
        current_alarm = 0;
        while (alarm_list == NULL)
        {
            /*链表为空，则等待*/
            pthread_cond_wait(&alarm_cond, &alarm_mutex);
        }

        /*摘取alarm链表的第一个元素*/
        alarm = alarm_list;
        alarm_list = alarm->link;
           
        now = time(NULL);
        expired = 0;
        if (alarm->time > now)
        {
#ifdef DEBUG
            printf("[waiting: %d (%d)\"%s\"]\n]", alarm->time, alarm->time - time(NULL), alarm->message);
#endif
            cond_time.tv_sec = alarm->time;
            cond_time.tv_nsec = 0;
            current_alarm = alarm->time;
            while (current_alarm == alarm->time)
            {
                status = pthread_cond_timedwait(&alarm_cond, &alarm_mutex, &cond_time);
                if (status == ETIMEDOUT)
                {
                    expired = 1;
                    break;
                }
                if (status != 0)
                {
                    err_abort(status, "cond timewait");
                }
            }

            if (!expired)
            {
                alarm_insert(alarm);
            }
        }
        else
        {
            expired = 1;
        }

        if (expired)
        {
            printf("(%d) %s\n", alarm->seconds, alarm->message);
            free(alarm);
        }
    }
}


int main(int argc, char *argv[])
{
    int status;
    char line[128];
    alarm_t *alarm;
    pthread_t thread;

    status = pthread_create(&thread, NULL, alarm_thread, NULL);
    if (status != 0)
    {
        err_abort(status, "Create alarm thread");
    }

    while (1)
    {
        printf("Alarm> ");
        if (fgets(line, sizeof(line), stdin) == NULL)
            exit(0);

        if (strlen(line) <= 1)
            continue;

        alarm = (alarm_t *)malloc(sizeof(alarm_t));
        if (alarm == NULL)
        {
            errno_abort("allocate alarm");
        }
        
        if (sscanf(line, "%d %64[^\n]", &alarm->seconds, alarm->message) < 2)
        {
            fprintf(stderr, "Bad command\n");
            free(alarm);
        }
        else
        {
            pthread_mutex_lock(&alarm_mutex);

            alarm->time = time(NULL) + alarm->seconds;
            alarm_insert(alarm);
           
            pthread_mutex_unlock(&alarm_mutex);
        }
    }
}


瓦釜苑
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POSIX 多线程程序设计
GAME-LAB（游戏开发，微信公众号：fury-programer）
02-05 1万+
POSIX 多线程程序设计  Blaise Barney, Lawrence Livermore National Laboratory  目录表 摘要   译者序Pthreads 概述   什么是线程?   什么是Pthreads?   为什么使用Pthreads?   使用线程设计程序
Linux高级程序设计 第三版 源码（示例代码）（杨宗德）
06-14
《Linux高级程序设计》第三版是杨宗德教授的经典之作，深入探讨了在Linux操作系统下进行高级程序开发的方方面面。这本书的源码包含了丰富的示例，对于学习和理解Linux系统编程有着极大的帮助。通过分析这些示例代码...
POSIX线程同步
weixin_34032621的博客
07-10 141
在posix编程中，如果在不同的线程中几乎同一时间操作同一个变量的时候，就会出现不同步。 如何解决这样的问题，这里需要用到互斥量，互斥锁的概念。请看UNIX环境高级编程P299页 #include <stdio.h> #include <unistd.h> #include <pthread.h> //线程1 vo...
UNIX Linux实验教程 5实验五Linux多线程程序设计.doc
09-26
本资源是关于UNIX Linux实验教程的第五实验，主要讲解Linux多线程程序设计的知识点。该实验的目的是让学生加深对线程概念的理解，并掌握使用 POSIX 线程机制进行多线程应用程序的编程方法。 实验指导中，首先讲解了...
嵌入式操作系统：第9章 嵌入式Linux多线程开发.ppt
05-31
这些同步机制是防止竞态条件和死锁的关键，确保多线程程序的正确性和稳定性。 在嵌入式Linux系统中，多线程技术广泛应用于实时任务调度、并发服务处理和高效数据处理等领域。掌握多线程编程不仅可以提升系统的并发...
并行程序设计导论课后答案_2.7z
11-20
在C语言中，可以使用POSIX线程库（pthread）进行多线程编程。 3. **并行算法**：并行算法设计是并行程序设计的核心，它涉及到如何将问题分解为可并行执行的部分。例如，快速傅里叶变换（FFT）、排序算法（如归并...
linux 高级程序设计第三版（杨宗德著）
07-23
《Linux高级程序设计》第三版，由杨宗德编著，是针对Linux系统进行深入编程的一本经典教材。这本书旨在帮助读者理解Linux环境下的高级编程技术，涵盖了从基本的系统调用到复杂的进程通信机制等多个方面。以下是该书...
POSIX多线程程序设计
03-20
POSIX多线程程序设计：如何使用多线程进行并行计算和提高计算效率。线程程序设计以及一般的线程程序会遇到的问题。
POSIX多线程程序设计.pdf
12-02
内容简介 《POSIX多线程程序设计》深入描述了IEEE的开放系统接口标准——POSIX线程，通常称为Pthreads标准。本书首先解释了线程的基本概念，包括异步编程、线程的生命周期和同步机制；然后讨论了一些高级话题，包括属性对象、线程私有数据和实时调度。此外，本书还讨论了调度的问题，并给出了避免错误和提高性能等问题的有价值的建议。本书使用了大量注释过后 实例来解释实际的概念，并包括Pthreads的简单索引和对标准化的展望。 《POSIX多线程程序设计》适合有经验的C语言程序员阅读，也适合多线程人员参考。
POSIX多线程程序设计（中文）pdf
06-02
一本经典不错的见解linux下多线程开发的书籍，值得一读。
POSIX多线程程序设计（第5章：线程高级编程）
瓦釜苑
08-25 550
管理数据初始化、属性对象、取消线程、线程的私有数据、Pthreads为实时调度提供的功能
POSIX多线程程序设计（四）线程同步
D.D.U的博客
04-13 573
使用线程编写稍有难度的程序，一般都需要在线程间共享数据或以一致的顺序在线程间执行一组操作。 不变量、临界区 不变量是由程序作出的假设，特别是有关变量组间关系的假设。当使用一个队列来保存你想用的特殊数据时，你要为队列指定一个队列头指针，指向一个队列的最开头的第一个元素，同时这个数据元素也应该包含指向下一个元素的指针。 临界区（串行数据）是指影响共享数据的代码段。一般，临界区总能对应一个数据...
Linux POSIX线程库中线程同步的三种常用方式
qq_43920560的博客
03-08 513
一、互斥锁（互斥） 使用步骤： 1、定义一个互斥锁变量：pthread_mutex_t mutex; 2、初始化互斥锁：预设互斥锁的初始值：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER（编译时初始化锁位解锁状态） 初始化互斥锁的函数 （a）函数原型 #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *restrict mutex,
POSIX多线程程序设计（三）线程的状态及简单使用
D.D.U的博客
04-03 450
POSIX多线程程序设计（三） &gt;&gt;如何选择使用线程或不使用线程 本身是非并发的问题，如果使用了多线程只会降低程序的性能并使用程序复杂。 例如： 如果程序中的每一步都需要上一步的结果，则使用多线程不会有任何帮助，因为每个线程都不得不等待其它线程的结束。 最适合使用线程的应用： 1. 计算密集型应用 2. I/O密集型应用 基本的线程同步模型为：使...
深入理解多线程编程：POSIX与Solaris线程实战
第4章涉及线程同步机制，如互斥锁、条件变量、信号量等，这些都是保证多线程程序正确执行的关键，避免数据竞争和其他并发问题。 第5章讨论了为了支持多线程而对操作系统环境所做的修改和调整，这包括内存管理、调度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值