C语言通过案例讲解并发编程模型

目录
  • 1、按照指定的顺序输出
  • 2、生产者消费者模型
  • 3、读写锁

下面代码、思路等来源于b站郭郭 和CSAPP样例,同时希望大家好好读一下CSAPP的内容,真的讲的很好

1、按照指定的顺序输出

我们执行两个线程:foo1 和foo2

foo1:打印step1, step3

foo2:打印step2

请用并发使得按照1 2 3 的顺序输出

答:首先两个线程执行顺序不可预判,我们必须保证打印step2之前step1就打印好了,因此需要阻塞一下step2,实现的方式是初始化sem为0,只有打印完step1后(然后进行解锁,V操作)step2才能执行

同理,只有打印完step2后才解开阻塞step3的锁,具体看代码实现就明白了

#include "csapp.c"

sem_t step1_done, step2_done;

void*  foo1() {
    printf("test1 is done\n");
    V(&step1_done);                  //step1执行完毕了,那么foo2的阻塞就会被解开
    P(&step2_done);                  //测试是否step2执行完毕,
    printf("test3 is done\n");
    return NULL;
}

void* foo2() {
    P(&step1_done);
    printf("test2 is done\n");
    V(&step2_done);                  //step2执行完毕,解开打印step的锁
    return NULL;
}

int main()
{
    pthread_t tid1, tid2;
    Sem_init(&step1_done, 0, 0);            //第二个参数为0:在线程之间进行, 第三个参数初始化都为零
    Sem_init(&step2_done, 0, 0);

    Pthread_create(&tid1, NULL, foo1, NULL);
    Pthread_create(&tid2, NULL, foo2, NULL);

    //保证线程执行完毕之后主线程才退出,否则线程都执行不了了
    Pthread_join(tid1, NULL);
    Pthread_join(tid2, NULL);

    exit(0);

}

2、生产者消费者模型

主要的就是在生产和消费函数中对于信号量的处理

错误实例:

void sbuf_insert(subf_t* sp, int item) {
    sem_wait(&sp->mutex);
  	sem_wait(&sp->slots);

    //将项目放进buf中
    sp->buf[(++sp->rear) % (sp->n)] = item;

    sem_post(&sp->items);
    sem_post(&sp->mutex);

}

void sbuf_remove(sbuf_t* sp) {
  sem_wait(&sp->mutex);
  sem_wait(&sp->items);

  //do works

  sem_post(&sp->slots);
  sem_post(&sp->mutex);
}

如果我们在处理的时候先拿到 互斥锁,可能就会引起死锁

假设现在buf是满的,生产者拿到了互斥锁,但是自己因为没有空闲被 block…

此时消费者同样因为拿不到互斥锁而被 block…

其他的生产者同样也是没有 互斥锁被block…

解决方法:

比较简单,调换一下顺序就好了。相当于我们生产者、消费者在进行的时候 明确我到底要操控哪个格子 然后再拿mutex

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

typedef struct sbuf{
    int *buf;               /*堆上开辟的内存,用于存储*/
    int n;                  /*cap of the buf*/
    int front;              //第一个item
    int rear;               //最后一个item

    sem_t mutex;            //获取临界区的锁
    sem_t slots;            //空槽数目
    sem_t items;            //已经生产了的数目
}subf_t;

void sbuf_init(subf_t* sp, int n) {
    sp->n     = n;
    sp->buf   = static_cast<int *>(calloc(n, sizeof(int)));
    sp->front = 0;
    sp->rear  = 0;

    sem_init(&sp->mutex, 0, 1);
    sem_init(&sp->slots, 0, n);
    sem_init(&sp->items, 0, 0);
}

void sbuf_deinit(subf_t*sp) {
    free(sp->buf);
}

void sbuf_insert(subf_t* sp, int item) {
    //首先应该对信号量slots判断,你生产者看中
    sem_wait(&sp->slots);
    sem_wait(&sp->mutex);

    //将项目放进buf中
    sp->buf[(++sp->rear) % (sp->n)] = item;

    //CSAPP中提到,解锁的顺序一般是和加锁的顺序是相反的
    sem_post(&sp->mutex);
    sem_post(&sp->items);
}

int  sbuf_remove(subf_t* sp) {
    int item;
    sem_wait(&sp->items);       //我看上哪个格子的产品了
    sem_wait(&sp->mutex);

    item = sp->buf[(++sp->front) % (sp->n)];

    sem_post(&sp->mutex);
    sem_post(&sp->slots);
    return item;
}

3、读写锁

第一类读者、写者问题(读者优先)

  • 不会让读者进行等待的,除非现在的权限是写者的
  • 也就是说读者不会因为有一个写者在等待

实现:

信号量:w维护着对于critical section的访问, mutex维护这对于共享变量readcnt(当前在临界区的读者的数量)的访问

每当写者进入了临界区,就对w进行加锁,离开就解锁。保证了任意时刻临界区最多只能有一个写者

只有第一个读者进入的时候对W加锁,最后一个才释放,那么只要还有一个读者在,其他任意的读者就能够无障碍的进入,同样会导致 写者饥饿

int readcnt = 0;
sem_t ,mutex = 1, w = 1;

void reader() {
  while (1) {
    P(&mutex);
    readcnt++;
    if (readcnt == 1) 	//第一个进入的读者
      P(&w);						//上锁,写者不能写了
    V(&mutex);					//解开对于readcnt的保护锁

    /*
    		临界区的工作

    */

    P(&mutex);
    readcnt--;
    if (readcnt == 0)
      V(&w);								//最后一个读者了, 解开阻塞写者的锁
    V(&mutex);							//解开对readcnt的保护锁
  }
}

void writer() {
  while (1) {
    P(&w);

    /*
    	临界区工作

    */
    V(&w);
  }
}

到此这篇关于C语言通过案例讲解并发编程模型的文章就介绍到这了,更多相关C语言 并发编程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++11并发编程:多线程std::thread

    一:概述 C++11引入了thread类,大大降低了多线程使用的复杂度,原先使用多线程只能用系统的API,无法解决跨平台问题,一套代码平台移植,对应多线程代码也必须要修改.现在在C++11中只需使用语言层面的thread可以解决这个问题. 所需头文件<thread> 二:构造函数 1.默认构造函数 thread() noexcept 一个空的std::thread执行对象 2.初始化构造函数 template<class Fn, class... Args> explicit th

  • C语言通过案例讲解并发编程模型

    目录 1.按照指定的顺序输出 2.生产者消费者模型 3.读写锁 下面代码.思路等来源于b站郭郭 和CSAPP样例,同时希望大家好好读一下CSAPP的内容,真的讲的很好 1.按照指定的顺序输出 我们执行两个线程:foo1 和foo2 foo1:打印step1, step3 foo2:打印step2 请用并发使得按照1 2 3 的顺序输出 答:首先两个线程执行顺序不可预判,我们必须保证打印step2之前step1就打印好了,因此需要阻塞一下step2,实现的方式是初始化sem为0,只有打印完step

  • Go语言运算符案例讲解

    算数运算符 算数运算符和C语言几乎一样 运算符 描述 实例 + 相加 A + B - 相减 A - B * 相乘 A * B / 相除 B / A % 求余 B % A ++ 自增 A++ – 自减 A– 注意点: 只有相同类型的数据才能进行运算 package main import "fmt" int main(){ var num1 int32 = 10 //var num2 int64 = num1 // 类型不同不能进行赋值运算 var num2 int64 = int64(

  • Java并发编程之内存模型

    目录 一.Java内存模型的基础 1.1 并发编程模型的两个关键问题 1.2 Java内存模型的抽象结构 1.3 从源代码到指令重排序 1.4 写缓冲区和内存屏障 1.4.1 写缓冲区 1.4.2 内存屏障 1.5 happens-before 简介 简介: Java线程之间的通信对程序员完全透明,内存可见性问题很容易困扰Java程序员,这一系列几篇文章将揭开Java内存模型的神秘面纱. 这一系列的文章大致分4个部分,分别是: Java内存模型基础,主要介绍内存模型相关基本概念 Java内存模型

  • Golang并发编程重点讲解

    目录 1.通过通信共享 2.Goroutines 3.Channels 3.1 Channel都有哪些特性 3.2 channel 的最佳实践 4.Channels of channels 5.并行(Parallelization) 6.漏桶缓冲区(A leaky buffer) 1.通过通信共享 并发编程是一个很大的主题,这里只提供一些特定于go的重点内容. 在许多环境中,实现对共享变量的正确访问所需要的微妙之处使并发编程变得困难.Go鼓励一种不同的方法,在这种方法中,共享值在通道中传递,实际

  • C语言指针引用数组案例讲解

    前言:C语言中指针玩的是什么,是内存,要想学好指针的小伙伴们要先对数据在内存中是怎么玩的做一番了解~       当在程序中定义一个变量时,系统会根据其数据类型为其开辟内存空间,例如Visual C++为整型变量分配四个字节的空间,为单精度浮点型变量分配四个字节,为字符型变量分配一个字节,内存中每个字节都有自己独立且唯一的一个编号,这就是地址 ,如下图,系统为变量i分配了2000~2004的存储单元. _访问变量的方式_有如下图两种: 第一种直接访问方式,直接通过变量名访问,变量名与地址有一一对

  • java并发编程专题(八)----(JUC)实例讲解CountDownLatch

    CountDownLatch 是一个非常实用的多线程控制工具类." Count Down " 在英文中意为倒计数, Latch 为门问的意思.如果翻译成为倒计数门阀, 我想大家都会觉得不知所云吧! 因此,这里简单地称之为倒计数器.在这里, 门问的含义是:把门锁起来,不让里面的线程跑出来.因此,这个工具通常用来控制线程等待,它可以让某一个线程等待直到倒计时结束, 再开始执行. CountDown Latch 的构造函数接收一个整数作为参数,即当前这个计数器的计数个数. public Co

  • C语言异常处理机制案例讲解

    异常处理机制:setjmp()函数与longjmp()函数 C标准库提供两个特殊的函数:setjmp() 及 longjmp(),这两个函数是结构化异常的基础,正是利用这两个函数的特性来实现异常. 所以,异常的处理过程可以描述为这样: 首先设置一个跳转点(setjmp() 函数可以实现这一功能),然后在其后的代码中任意地方调用 longjmp() 跳转回这个跳转点上,以此来实现当发生异常时,转到处理异常的程序上,在其后的介绍中将介绍如何实现. setjmp() 为跳转返回保存现场并为异常提供处理

  • Java之网络编程案例讲解

    Java基础之网络编程 基本概念 IP:每个电脑都有一个IP地址,在局域网内IP地址是可变的. 网络通信协议:通信协议是对计算机必须遵守的规则,只有遵守这些规则,计算机之间才能进行通信.这就好比在道路中行驶的汽车一定要遵守交通规则一样,协议中对数据的传输格 式.传输速率.传输步骤等做了统一规定,通信双方必须同时遵守,最终完成数据交换. TCP协议(传输控制协议):是面向连接的传输层协议,应用程序在使用TCP之前,必须先建立TCP连接,在传输数据完毕后,必须释放已经建立的连接(跟打电话是否类似).

  • Java之线程编程的4种方法实现案例讲解

    1.继承Thread public class T4 { public static void main(String[] args) { System.out.println(Thread.currentThread()); Thread t1 = new A1(); t1.start(); } } class A1 extends Thread{ @Override public void run() { for(int i=0;i<10;i++) { System.out.println(

  • C语言 socketpair用法案例讲解

    socketpair()函数的声明: #include <sys/types.h> #include <sys/socket.h> int socketpair(int d, int type, int protocol, int sv[2]): socketpair()函数用于创建一对无名的.相互连接的套接子.  如果函数成功,则返回0,创建好的套接字分别是sv[0]和sv[1]:否则返回-1,错误码保存于errno中. 基本用法:  这对套接字可以用于全双工通信,每一个套接字既

随机推荐