线程的同步和互斥

1.基本概念

同步:指定线程的执行顺序,比如有两个线程A,B都要访问资源的时候,B执行了途中需要A的结果,所以B先让出资源,等A执行结束后再执行B

互斥:多个线程访问系统资源的时候,同时只能有一个线程对资源进行访问

2.线程间的同步和互斥是通过操作系统中信号量和PV原语来实现的

PV操作是由P操作原语和V操作原语组成(原语是不可中断的过程),对信号量进行操作,具体定义如下:

P(S):①将信号量S的值减1,即S=S-1;

②如果S³0,则该进程继续执行;否则该进程置为等待状态,排入等待队列。

V(S):①将信号量S的值加1,即S=S+1;

②如果S>0,则该进程继续执行;否则释放队列中第一个等待信号量的进程。

3.举个栗子(经典的生产者和消费者模式)

条件1:生产者在生产前需要看实体店是否缺货(定义为判断是否为空的同步信号量),如果缺货则开始生产,而消费者判断是否有货(判断是否为满的同步信号量),有货才可以购买。(引入同步信号量)

条件2:因为实体店有限,多个生产者在生产产品时候需要指明往哪个实体店放,这样其他生产者此时就不能再生产往该实体店放的产品了,否则两个生产者同时生产一个实体店需要的产品,都生产完只能放一个生产者的产品,另一个生产者的产品就没地方放了。(引入互斥信号量)

下面看操作:

1).定义两个同步信号和一个互斥信号量

empty=1(判断是否为空的同步信号量)

full=0(判断是否为满的同步信号量)

mutex=1(互斥信号量一般定义为1)

2).生产者操作

while(true)

{

P(empty)//查看是否能生产

p(mutex)//锁定实体店,别的生产商不可向该实体店生产产品

临界区(定义了对临界资源的访问代码,这里临界资源指实体店)

V(mutex)//解除锁定实体店

V(full)//通知消费者可以购买

}

3).消费者操作

while(true)

{

P(empty)//查看是否能购买

p(mutex)//锁定实体店,别的消费商不可向该实体店购买产品

临界区(定义了对临界资源的访问代码,这里临界资源指实体店)

V(mutex)//解除锁定实体店

V(full)//通知生产者可以生产

}

4.例题

有三个进程PA、PB、PC协作解决文件打印问题:PA每次将一条文件记录从磁盘读入输入缓冲区,PB将输入缓冲区的内容复制到输出缓冲区中,PC则将输出缓冲区中的内容打印出来,PC每执行一次,打印一条文件记录。输入缓冲区的容量与输出缓冲区完全相同,请用信号量机制保证文件的正确打印

思路:

[1] PA和PB因共享输入缓冲区Cache-I而相互制约,所以设置互斥信号量CI;同理,设置互斥信号量CO
控制进程PB和PC对输出缓冲区Cache-O的访问。

[2] 因三个进程的直接制约关系而设置的同步信号量如下: 
ab:PA的执行依赖PB释放缓冲区为空的信息; ba:PB的执行要检测PA的数据是否放入缓冲区; 
bc:PB的执行要检测有PC释放的输出缓冲区为空的信息; cb:PC执行需要检测PB的数据是否放入缓冲区。

[3]一个缓冲区定义2同1互(信号量)

答案:

P(ab)   P(CI)   放入缓冲区Cache-I   V(CI)   V(ba)

P(ba)   P(CI)   取缓冲区Cache-I的数据   V(CI)   V(ab)

P(bc)   P(co)   放入缓冲区Cache-O   V(co)   V(cb)

P(cb)   P(co)   取缓冲区Cache-O的数据   V(co)   V(bc)

时间: 2024-10-10 17:28:10

线程的同步和互斥的相关文章

线程的同步与互斥,死锁

线程的同步与互斥 多个线程同时访问共享数据时可能会发生冲突,比如两个线程同时把一个全局变量加1,结果可能不是我们所期待的: 我们看这段代码的执行结果: #include <stdio.h> #include <stdlib.h> #include <pthread.h> static int g_count=0; void *thread(void *arg) { int index=0; int tmp=0; while(index++<5000) { tmp=

线程概念及线程的同步与互斥

线程概念:它是运行在进程内部的的一个基本执行流,多线程的控制流程可以长期并存,一个进程中的数据段和代码段都是被该进程中的多个线程共享的,若定义一个函数,每个线程都可以调用,若定义一个全局变量,每个线程都可以访问. 线程还共享进程的以下内容:1.文件描述符表 2.当前的工作目录 3.用户id(uid)和组id(gid) 4.每种信号的处理方式. 但每个线程还必须有自己的私有部分:1.线程id 2.硬件上下文(硬件寄存器的值,栈指针等) 3.自己的栈空间(运行时的临时数据都要保存在自己的栈空间上)

java的线程问题同步与互斥

以前学过java的线程,但是当时对Tread的理解不是很深,对于里面的同步与互斥,生产者与消费者问题,理解的不够深入,这次又从新学习java的多线程,感觉对线程的理解更加的深入了,觉得有必要写下博客记录下. 本文原创,转载请著明:http://blog.csdn.net/j903829182/article/details/38420503 1.java实现线程的方法: 1.实现Runnable接口,重写run方法,通过Thread的start方法启动线程.这种方法可以实现资源的共享 2.继承T

Linux环境下线程的同步与互斥以及死锁问题

由于本次要讨论操作系统的死锁问题,所以必须先研究的是linux环境下的线程同步与互斥 先看下面的代码 大家猜想输出应该是什么呢? 结果是下面这个样子 好吧,似乎并没有什么区别... 那么下面再看这段代码(请无视并忽略屏蔽的内容...) 大家猜想正确的结果是什么呢?5000,10000? 好吧,或许你们都错了. 在运行了一段时间后,它的结果是这样的. 是不是又对又错? 为什么呢? 这就是因为程序中printf语句作用:本身是库函数,所以必须进行系统调用,必须进入内核进行切换,有很大概率形成数据的混

线程的同步与互斥(死锁的产生和避免)

可以知道,一条语句对一个变量进行+1操作,转成汇编指令共有三条:将这个变量从内存中取出:将其值加1:再将加后的结果放回内存:当一个进程中的两个线程同时进行这个操作时,本来期望的是将变量进行两次加1,但中途有可能当一个线程刚从内存中将变量取出就被切换暂停了,此时线程会保存硬件上下文,第二个线程将变量加1之后前面切出去的线程回来继续执行,这时保存的还是变量原来的值,再将变量加1,会发现变量的最终结果并没有加2而是只加了1,因此这种操作并不是原子的. -------------------------

生产者与消费者模式(线程的同步与互斥)

死锁产生的四个条件: 1.互斥使用(资源独占) 一个资源每次只能给一个进程使用 .2.不可强占(不可剥夺) 资源申请者不能强行的从资源占有者手中夺取资源,资源只能由占有者自愿释放 .3.请求和保持(部分分配,占有申请) 一个进程在申请新的资源的同时保持对原有资源的占有(只有这样才是动态申请,动态分配) .4.循环等待 存在一个进程等待队列 {P1 , P2 , - , Pn}, 其中P1等待P2占有的资源,P2等待P3占有的资源,-,Pn等待P1占有的资源,形成一个进程等待环路 生产者:生产数据

Linux下线程的同步与互斥

一.线程的互斥 多个线程同时访问共享数据时可能会冲突,跟之前信号量的可重如性是同样的问题.如两个线程都要把某个全局变量增加1,这个操作在某平台需要三条指令完成: 1. 从内存读变量值到寄存器 2. 寄存器的值加1 3. 将寄存器的值写回内存 如下程序就会产生问题: 我们创建两个线程,每把g_count增加5000次,正常情况下最后g_count应该等于10000,但事实上每次运行该程序的结果都不一样. 对于多线程的程序,访问冲突的问题是很普遍的,解决的办法是引入互斥锁(Mutex,Mutual

Linux多线程编程——线程的同步与互斥

前言:无论是多线程编程还是多进程编程,控制好不同线程或不同进程之间同步和互斥问题是非常有必要的.同步是多个进程或线程共同完成某个任务,举例说,一个缓冲区的生产者和消费者问题,当生产者生产了一个商品时,等待的消费者就获得了一个消息知道可以去取走商品了,当消费者取走一个商品后,生产者就知道可以继续生产一个商品了,这是同步问题,所谓互斥问题,是指某个共享资源在一次操作中,只能被一个线程或进程占有,其他的线程或进程不能对它进行操作,比如对一个共享内存的读写操作,当一个进程对它写的时候,另一个进程就不能对

线程的同步之互斥量

互斥量: 当多个线程共享相同的内存时,需要每一个线程看到相同的视图.当一个线程修改变量时,而其他线程也可以读取或者修改这个变量,就需要对这些线程同步,确保他们不会访问到无效的变量 在变量修改时间多于一个存储器访问周期的处理器结构中,当存储器的读和写这两个周期交叉时,这种潜在的不一致性就会出现.当然这与处理器相关,但是在可移植的程序中并不能对处理器做出任何假设 为了让线程访问数据不产生冲突,这要就需要对变量加锁,使得同一时刻只有一个线程可以访问变量.互斥量本质就是锁,访问共享资源前对互斥量加锁,访

线程的同步与互斥(生产者与消费者模型)

一个进程中可以有多个线程,这些线程共享进程的资源,但当多个线程访问同一个资源时,在并不能保证操作是原子的情况下,就会产生冲突而使数据最终的结果不准确,像上次我们提到的将一个数进行加1操作需要三步:将数据从内存中取出:将数据加1:再将数据放回内存中,当多个线程并发执行这一操作时,有可能一个线程刚将数据从内存中取出就被临时切换出去了,这时别的线程进行加1操作,而当被切出去的线程重新回来继续执行加1操作时,这个数据已经改变了但是它拿到的还是原来的值,再进行加1放回内存时,结果就和我们所期望达到的不一样