进程同步问题(Process Synchronization)

已于 2022-01-20 14:34:37 修改
阅读量1k 收藏 7
点赞数
文章标签： 操作系统
于 2022-01-20 14:32:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/capslock813/article/details/122600737
版权

CH5 Process Synchronization

文章目录

I. 识别临界区(Race condition)

1. producer–consumer problem用计数器counter会产生的问题

1）producer

while(true)
{
    /*produce an item and put in next_produced  */
    while(counter==BUFFER_SIZE);	/*do nothing*/
    buffer[in]=next_produced;
    in=(in+1)%BUFFER_SIZE;
    counter++;
}

2）consumer

while (true){
    while (count == 0); // do nothing
    next_consumed =  buffer[out];
    out = (out + 1) % BUFFER_SIZE;
    counter--;
    /*consume the item in next_consumed*/
}

本质问题：并发执行程序代表着，进程在任意的指令流上都有可能被随时中断切换

在这里插入图片描述

2. 练习题

题目：有两个并发进程P1和P2，共享初值为1的变量x。P1对x加1，P2对x减1。加1和减1操作的指令序列分别如下所示。
在这里插入图片描述

两个操作完成后，x的值是（c）。

A. 可能为-1或3 B. 只能为1

C. 可能为0、1或2 D. 可能为-1、0、1或2

解：

① P1和P2并行运行

P1: x=1,R1=x, R1=R1+1=x+1=2
P2: x=1,R2=x, R2=R2-1=x-1=0

以上是两个进程并发而进行的步骤，而进程的最后一步无法并发进行，因而会出现：
R1→x=2，R2→x=0

所以，两个操作完成后，x的值可能为2，也可能为0

②P1先执行，P2后执行

P1: x=1,R1=x=1,R1=R1+1=1+1=2,x=R1=2
P2: x=1,R2=x=2,R2=R2-1=2-1=1,x=R2=1

所以，两个操作完成后，x的值为1

③P2先执行，P1后执行

P2: x=1,R2=x=1,R2=R2-1=1-1=0,x=R2=0
P1: x=0,R1=x=0,R1=R1+1=0+1=1,x=R1=1

所以，两个操作完成后，x的值也为1

所以综合以上三种情况可知x的值可能为0、1或2

II. 软件互斥方法

Solution to critical section problem（三大原则）:

①mutual exclusion

②progress（空闲让进）：临界区空闲的时候，可以让请求进入临界区的进程立即进入临界区

③bound waiting（有限等待）：对于请求访问的进程，应该保证在有限时间内进入临界区（相当于对于请求访问的进程不可以发生饥饿，就是一直进不去）

1. 单标志法

1）实现方法
在这里插入图片描述

2）问题

假如P0一直不访问临界区（此时turn=0），P1就无法访问临界区，违反了progress的原则

  • P0，P1是否可以互斥的进入临界区？
  • P0，P1是否会发生“饥饿”现象？
  • P0，P1是否会发生“死锁”现象？
2. 双标志先检查法

1）实现方法

注意：开始的时候 flag[0]=flag[1]=FALSE

在这里插入图片描述

2）问题

  • P0，P1是否可以互斥的进入临界区？
  • P0，P1是否会发生“饥饿”现象？
  • P0，P1是否会发生“死锁”现象？
3. 双标志后检查法

1）实现方法

在这里插入图片描述

2）问题

  • P0，P1是否可以互斥的进入临界区？

  • P0，P1是否会发生“饥饿”现象？

  • P0，P1是否会发生“死锁”现象？

    死锁一定强调的是都在等待对方进程来解锁

    在这里插入图片描述

4. 时间片改进算法

1）实现方法

在这里插入图片描述

2）问题

  • P0，P1是否可以互斥的进入临界区？

  • P0，P1是否会发生“饥饿”现象？

    会产生“饥饿”，因为flag[0]=flag[1]=true的时候，两个都进入了while循环，假如延迟时间设置的一样，两个进程同步切换，那就会一直在这个循环里面。

  • P0，P1是否会发生“死锁”现象？

5. Dekker’s Algorithm（有点麻烦，但是解决了问题）

在这里插入图片描述

6. Peterson Algorithm（暂时比较完美的解法）

在这里插入图片描述

P0:
flag[0]=true;	//我想用
turn=1	//但是您先用
while(flag[1]&&turn==1);	//您要是想用，那您先用
critical section
flag[0]=false	//我用完了

基本思想：

  • P0，P1是否可以互斥的进入临界区？
  • P0，P1是否会发生“饥饿”现象？
  • P0，P1是否会发生“死锁”现象？
7. 练习题

1）区分死锁和饥饿(变形的读者写者问题)
在这里插入图片描述

选B。

  • P1，P2是否会发生“饥饿”现象？（注意，可能有多个P1或者多个P2，比如读者写者问题）

    解释：按照序列①(x1=0),②(c1=1,y=0)⑦(x2=0)⑧(c2=1,y=-1,P2阻塞)③(x1=1)

    ​ 此时又来一个P1‘：①(x1=0),②(c1=2),③(x1=1)④(x1=0)⑤(c1=1,不执行V(y)的操作)⑥(x1=1)

    ​ 所以可以看出，P2必须等所有在P1后面来的P1’走了以后才可以从阻塞对面里面出来，如果无限个P1来了，P2就排不上队了（相当于P1那些小鳖孙儿们不停的插队）

  • P1，P2是否会发生“死锁”现象？

    解释：是否产生死锁的关键在于，会不会出现，两个人都阻塞然后还要等待对方来解锁。这里的操作序列是先让P2等待，当时P2等待的时候，P1是可以给他解锁的。不会出现两个都在等待的情况。

2）期中考试原题

在这里插入图片描述

在这里插入图片描述

此题答案选A

  • P0，P1是否可以互斥的进入临界区？

    解释：按照①②③④⑤⑥执行

  • P0，P1是否会发生“饥饿”现象？

    解释：按照①③②④的顺序执行，进程P0不需要进程P1的来解锁，对P1也不需要进程P0来解锁。只是这个序列会导致整个程序处于一个循环状态

  • P0，P1是否会发生“死锁”现象？

    解释：死锁的话，指的是，进程P0和P1都陷入一个忙等状态，要打开这个忙等状态必须要对方程序来解锁（比如双标志后检查法）

3）上课同学提出的算法
在这里插入图片描述

  • P0，P1是否可以互斥的进入临界区？

    解释：思路就是让flag[0]，flag[1]都先变成true，然后因为进入critical section之前的是要过掉这个if，跳出这个if的关键在于flag[0]和flag[1]的取值不一样。如果两个都变成true了以后让一个进程进入这个if，改变其中的一个flag，构成跳出if的条件，让对方程序进入critical section，然后自己也可以进入critical section。序列如下：flag[0]=flag[1]=false,

    6，20，7（没反应），21（没反应），8，22，9（flag[1]=true），23（flag[0]=true），10（进入P0的if循环），12，13，7（flag[0]=false），24，P1进入critical section。8，9(flag[1]=true)，10（跳出if循环），P0进入临界区

  • P0，P1是否会发生“饥饿”现象？

III. 硬件实现互斥方法（Synchronization Hardware）

1. 关闭中断（只能运用单处理器系统）

含义：就是不让中断出现，这样就不会有软件方法中交替中断的情况

缺点：过于鲁莽。因为有的进程如果在临界区的时间很长的话，中断是一个很好的选择。关中断还是适用于进入临界区的时间较短的时候（关了马上可以开）

2. 硬件方法（atomic hardware instructions）

atomic hardware instructions：Atomic = non-interruptible

优点：运用软件实现方法的问题其实根本在于“上锁”和“检查”是分开的，比如双标志先检查法，进入临界区以前先检查后上锁而导致了中断切换间的死锁问题：

在这里插入图片描述

所以如果“上锁”和“检查”变成了一气呵成的原子操作，且不会被中断打扰，那么实现起来就简单且容易操作

1）test_and_set()
  • ​ 程序使用test_and_set()指令实现互斥的逻辑：进程首先都会拿到一个lock，如果lock=F的话，那么就可以进入临界区。

​ 任何一个程序的lock无非就两种情况：

​ ① lock=T：lock=T，就把lock继续变成T然后在while里面盘旋

​ ② lock=F：lock=F，可以不在while里面循环，但是lock还是会变成T，这时候其他来的进程lock就是T，进不来。

do
{
    while(test_and_set(&lock));		/*aquire and set lock(相当于返回lock本来的值然后在set新的值)*/
    	/* critical section */  
    lock=F;	//解锁，把权力给其他程序
    	/* remainder section */ 
}while(T)

test_and_set()指令实现的代码：

bool test_and_set(bool *target)
{
    bool old = *target;	//用old存放原来lock的值
    *target = T;	//“上锁”：无论之前是否已经加锁，都需要将lock变成TRUE
    return old;		//“检查”：函数返回之前的lock值
}

  • 问题：有可能会出现starvation，因为进程只有抢到lock=FALSE才可以进入临界区，所以进程抢不到lock=FALSE就进不去临界区。

  • 解决：

在这里插入图片描述

2）compare_and_swap()

compare_and_swap程序实现逻辑：lock=0代表拿到锁了

do 
{
    while (compare_and_swap(&lock, 0, 1) != 0) ; /* do nothing */ 
          /* critical section */ 
    lock = 0; 
          /* remainder section */ 
}while(true);

compare_and_swap() 实现方式：

int compare_and_swap(int *value, int expected, int new_value)
{ 
    int old = *value; 	//“检查”：temp还是先把old的值先获取了
    if (*value == expected)  *value = new_value; //“上锁”：如果可以进入临界区就上锁
    return old; 
}
3. spining lock

while(!available) ; /*busy waiting*/

  • 缺点：当一个进程在临界区的时候，其他任何的进程必须在进入临界区以前进入busy waiting的状态，等到lock可以用为止。这样的busy waiting会浪费CPU周期。

  • 优点：当进程等待lock的时候可以不用进行context switching。所以当进程被锁的时间很短的时候还是有利于减小程序时间上的切换开销的，适用于多处理器系统（multiprocessor）

4. 练习题

在这里插入图片描述

IV. 信号量（Semaphore）

1. 定义信号量

每一个信号量都有一个正数value和一个进程链表list。当一个进程必须等待信号量时，就要被添加到进程链表

typedef struct
{
    int value;
    struct process *list;
}semaphore;

2. 信号量的实现

P操作的实现：

wait(semaphore *S)
{ 
    S->value--;
    if (S->value < 0){
        /*add this process to S->list;*/
        block();       
    }
}

V操作实现：

signal(semaphore *S)
{
	S->value++;
    if(S-value>=0){
       /*remove a process P from s->list*/
        wakeup(P);	//重新启动P（之前时阻塞）的进行
    }
}

V. 经典同步互斥例子

1. 互斥问题

  • 基本情景：同一个时间段只允许一个进程访问临界区

  • 实现方法：

semaphore mutex=1;
P1()
{
    ...
    P(mutex);	/*“加锁”:使用临界区前加锁/
    /*crtical section*/
    V(mutex);	/*“解锁”：使用完临界区以后解锁*/
}

P2()
{
    ...
    P(mutex);	/*“加锁”:使用临界区前加锁/
    /*crtical section*/
    V(mutex);	/*“解锁”：使用完临界区以后解锁*/
}

注：对于不同的临界资源要设置不同的信号量

在这里插入图片描述

2. 同步问题

  • 基本情景：两个并发运行的进程，P1有语句S1，P2有语句S2，要求在S1执行后才能执行S2。（相当于假如我们现在需要煮饭，我们要在开火之前要先放米和水，一定是有一个牵制关系在）
  • 解决方式：在“前操作”之后V，在“后操作”之前P
semaphore S=0

P1:

S1;
signal(S);

P2：

wait(S);	//如果S=0，wait(S),P2直接阻塞,必须需要P1才可以解锁
S2;

3. 同步+互斥问题

1）Bounded-Buffer Problem
  • 信号量初始化

在这里插入图片描述

  • empty信号量：用来限制buffer满了（empty=0），但是producer仍然要往里面放东西的情况

    在这里插入图片描述

  • full信号量：用来限制buffer空的（full=0），但是consumer还是要从buffer里面取东西的情况

在这里插入图片描述

  • mutex信号量：对于多个producer或者多个consumer同时操作的时候，假设n=5，empty=3。比如，现在producer1进程先执行到第6行，Buffer[1]=item1 ：

    do { 
       /* produce an item in next_produced */ 
          ... 
        wait(empty); 	//empty=2
          ... 
        Buffer[in] = next_produced ;		//in=1
        in = (in+1)% BUFFER_SIZE;
          ... 
        signal(full); 
          ...     
	}while (true);

    在这里插入图片描述

    然后producer1发生中断，producer2进程也执行同样的程序到第6行。因为in没有变，Buffer[1]=item2 ，所以producer2生产的item会在Buffer[1]=item 这里产生覆盖

    do { 
       /* produce an item in next_produced */ 
          ... 
        wait(empty); 	//empty=1
          ... 
        Buffer[in] = next_produced ;	//in=1
        in = (in+1)% BUFFER_SIZE;
          ... 
        signal(full); 
          ...     
   }while (true);

    在这里插入图片描述

  • 实现方式：

    同步关系：当buffer满，生产者不可以再生产；当buffer空，消费者不可以再消费。

    互斥关系：两个生产者或两个消费者之间不可以同时对buffer进行装入/取出操作。

  • producer：生产东西，如果满了（empty=0）不生产

    do
{
    /* produce an item in next_produced */ 
    ...
    wait(empty);	//if empty=0,block
    wait(mutex);
  
    Buffer[in] = next_produced ;
    in = (in+1)% BUFFER_SIZE;
	...
    signal(mutex);
    signal(full);
    
}while(T)

  • consumer：消费东西，如果是空的就不消费（full=0）

    do
{
    wait(full);	//if full=0,block
    wait(mutex);
    ...
   
    next_consumed = buffer[out]; 
    out = (out + 1) % BUFFER_SIZE;
    ...
    signal(mutex);
    signal(empty);
     /*consume the item in next_consumed */

}while(T)

  • wait(empty)和wait(mutex)可以互换吗？

    不可以，会产生死锁问题。

    在这里插入图片描述

    按照①②③④的顺序执行就会锁死

2）多生产者消费者问题

在这里插入图片描述

互斥关系：爸爸和妈妈之间，儿子和女儿之间对盘子的互斥。

在这里插入图片描述

同步关系：

  • 爸爸和女儿之间的同步（只有爸爸放了苹果，女儿才可以拿）
  • 儿子和妈妈之间（只有妈妈放了橘子，儿子才可以拿）
  • 只有盘子为空的时候，父亲或妈妈才可以往盘子放东西
Initialization：

semaphore orange=0;
semaphore apple=0;
semaphore mutex=1;

爸爸F：

do
{
	wait(mutex);	//if(mutex=0),代表盘子是被占了的，需要被block
    /*put the apple in the plane*/
    signal(apple)	
	
}while(T)

妈妈M：

do
{
	wait(mutex);	//if(mutex=0),代表盘子是被占了的，需要被block
    /*put the orange in the plane*/
    signal(orange)	
	
}while(T)

女儿D：

do
{
	wait(apple);	
    /*retrieve the apple in the plane*/
    signal(mutex)	
	
}while(T)

儿子S：

do
{
	wait(orange);	
    /*retrieve the orange in the plane*/
    signal(mutex)	
	
}while(T)
3）Dining-Philosophers Problem

在这里插入图片描述

情景：

  • Philosophers spend their lives alternating thinking and eating

  • Don’t interact with their neighbors, occasionally try to pick up 2 chopsticks (one at a time) to eat from bowl

  • Need both to eat, then release both when done

问题分析：会形成死锁

在这里插入图片描述

semaphore chopstick[5]={1,1,1,1,1}
do
{
    wait(chopstick[i]);	//拿左边筷子
    wait(chopstick[(i+1)%5])	//拿右边筷子
        /*eating*/
    signal(chopstick[i]);	//放下左边筷子
    wait(chopstick[(i+1)%5])	//放下右边筷子
        /*thinking*/
}while(T)

解决方法：

  • 最多允许四位哲学家进餐

    在这里插入图片描述

    semaphore chopstick[4]={1,1,1,1}
do
{
    wait(chopstick[i]);	//拿左边筷子
    wait(chopstick[(i+1)%5])	//拿右边筷子
        /*eating*/
    signal(chopstick[i]);	//放下左边筷子
    wait(chopstick[(i+1)%5])	//放下右边筷子
        /*thinking*/
}while(T)

  • 奇数号的哲学家先拿左边的筷子，然后再拿右边的筷子；偶数号的哲学家先拿起右边的筷子，然后再拿左边的筷子

    在这里插入图片描述

    semaphore chopstick[5].value={1,1,1,1,1}
Pi=0,2,4
do
{
 	wait(chopstick[(i+1)%5]);
    wait(chopstick[i]);
    /*eating*/
    signal(chopstick[i+1]%5);
    signal(chopstick[i]);
    /*thinking*/
}while(T)

    Pi=1,3
do
{
    wait(chopstick[i]);
    wait(chopstick[i+1]);
    /*eating*/
    signal(chopstick[i]);
    signal(chopstick[i+1]);
    /*thinking*/
}while(T)

  • 把取筷子也变成一个互斥的过程

    例：①比如0号哲学家先拿起左边和右边的筷子，然后3号哲学家也可以顺利的拿起左边和右边的筷子（mutex可以让三号哲学家进去）

    在这里插入图片描述

    ②比如还是0号哲学家先拿起左边和右边的筷子，然后1号哲学家要拿筷子，但是被chopstick[1]挂掉了

    Pi=0,1,2,3,4
semaphore chopstick[5].value={1,1,1,1,1};
semaphore mutex=1;

Pi()
{
    do
    {
        wait(mutex);
        wait(chopstick[i]);
        wait(chopstick[(i+1)%5]);
        signal(mutex);
        /*eating*/
        signal(chopstick[i]);
        wait(chopstick[(i+1)%5]);
        /*thinking*/
    }while(T)    
}

  • 第四个进程先拿起4再拿起0，相当于如果0，1，2，3这四个哲学家同时拿起了左边的筷子，4虽然拿不起右边的筷子，但是只要3拿起右边的筷子然后放下左边和右边的筷子就可以解锁

    在这里插入图片描述

    在这里插入图片描述

    process  Pi( )	(i = 0, 1, 2, 3)	     
{
    while (true) 
    {
        wait (chopstick[i]); 
        wait (chopstick[i+1]); 
        eating ;              
        signal (chopstick[i]); 
        signal (chopstick[i+1]);
        thinking ;  
    }
} 

    process  P4( )	
{
    while (true) 
    {
        wait (chopstick[0]);	//先拿右边的筷子 
        wait (chopstick[4]); 
        eating ;             
        signal (chopstick[0]); 
        signal (chopstick[4]); 
        thinking ;       
    }
}
Alvis_Li36
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程间同步互斥问题——银行柜员服务问题1
08-03
1. 某个号码只能由一名顾客取得 2. 不能有多于一个柜员叫同一个号 3. 有顾客的时候，柜员才叫号 4. 无柜员空闲的时候，顾客需要等待 5. 无顾客的时候，
操作系统练习-信号量
热门推荐
Howie66的博客
02-07 1万+
##单选题 临界区是指()  并发进程中用于实现进程互斥的程序段 进程中访问临界资源的那段代码 一段缓冲区 一个数据区 解释：每个进程有一个代码段称为临界区，在该区中进程可能改变共同变量、更新一个表、写一个文件等。 多个进程对信号量S进行了6次P操作，2次V操作后，现在信号量的值是-3，与信号量S相关的处于阻塞状态的进程有几个（）  1个 2个 3个 4个 解释
《操作系统》期末主观题梳理
My apologize的博客
05-27 6445
①硬实时任务是指系统必须满足任务对截止时间的要求，否则可能出现难以预测的结果，如运载火箭的控制等。②软实时任务对截止时间的要求并不严格，偶尔错过任务的 截止时间，对系统产生的影响也不大，如网页内容的更新、火车售票系统剩余票数的更新等。
【操作系统】习题1
only_nobody的博客
05-20 9780
有两个并发执行的进程P1和P2，共享初值为1的变量x。P1对x加1，P2对x减1。加1和减1 的指令序列分别如下所示： 两个操作完成后，x的值【 C 】。 A 可能为-1或3 B 只能为1 C 可能为0、1或2 D 可能为-1、1或2 解：由于对两个并发进程P1与P2没有先后进行的要求，因此会出现三种情况： ①P1先执行，P2后执行。 P1进程：x→R1=1，x=x+1=2，R1→x=...
计算机学科专业基础综合811,2017年四川省培养单位成都计算机应用研究所408计算机学科专业基础综合之计算机操作系统考研仿真模拟题...
weixin_39756416的博客
06-20 244
一、选择题1． 有两个并发执行的进程P1和P2, 共享初值为1的变量x 。P1对x 加1，P2对x 减1。两个操作完成后，x 的值( )。A. 可能为-1或3B. 只能为1C. 可能为0、1或2D. 可能为-1、0、1或2【答案】C【解析】执行①②③④⑤⑥结果为1，执行①②④⑤⑥③结果为2, 执行④⑤①②⑨⑥结果为0, 结果-1无法得到。这个题目的进程之间没有同步关系，因此通过分步尝试就可...
进程同步、进程互斥
lizhuangabby的博客
06-10 581
进程同步、进程互斥
操作系统进程管理经典考研题分享
MonkeyCoder的专栏
05-11 4330
（09年）24下列进程调度算法中，综合考虑进程等待时间和执行时间的是（D）  A．时间片轮转调度   B. 短进程优先调度算法    C. 先来先服务调度算法   D.高响应比优先调度算法 （10年）26．下列选项中，降低进程优先级的合理时机是（A） A.进程的时间片用完   B.进程刚完成I/O，进入就绪列队 C.进程长期处于就绪列队中        D.进程从就绪态转为运行态
多处理器（Multiprocessor）的基本概念
qq_39918677的博客
10-12 7071
1、多核处理器和向量处理器 什么是并行计算？先考虑传统的串行处理模式，假设需要解决某个问题，串行计算的方式是将该问题视为若干个步骤（或者指令），处理器使用顺序序列的方式处理这些指令，当所有指令处理完成之后会出现最终的问题结果，从而解决了问题。不过，串行处理方式在速度上存在瓶颈。当问题不是太大时，这种方式可行。但是，当处理大问题或者想要更快的计算更多事情，是否有能克服处理器速度瓶颈并增加计算速度的方法呢？答案就是并行计算。并行计算将要解决的问题分解为很多小问题，每个小问题可以被同时独立的进行计算。通过这种方式
操作系统习题集(部分)
CS@zeny的博客
07-10 5633
操作系统练习题：习题来自老师给的题目， 部分答案有解析。当然这里的题并不多，难度一般， 没有达到考研的难度，仅作为期末复习参考。
OS-Assignments:大学二年级时，我完成了操作系统课程的3项作业。它具有在Linux OS中进行文件处理，线程进程同步以及进程间通信的功能。
03-20
操作系统分配大学二年级时，我完成了操作系统课程的3项作业。它具有在Linux OS中进行文件处理，线程/进程同步以及进程间通信的功能。
mage2vuestorefront：Magento到Vue店面的数据泵-同步Magento2 API和vue店面的NoSQL数据库之间的产品，类别和产品到类别的链接
02-03
这是Magento与Vue Storefront ElasticSearch数据库之间的多进程数据同步器。 此时，同步可与以下实体一起使用： 产品展示 分类目录 税则 属性 产品到类别 评论（需要自定义模块Divante / ReviewApi才能工作） ...
VOS服务器
02-04
简而言之Desktop=Process和Server=OS 。 演示1：计划 我们将尝试在云上模拟各种调度算法。 为简单起见，我们假设为每个进程指定了执行时间。 如果客户端脚本的许多实例正在运行，则服务器需要一种算法来满足所有...
92道Java多线程与并发面试题含答案（很全）
最新发布
01-03
进程（Process）：进程是操作系统分配资源（如内存）和调度的单位。一个进程可以包含多个线程，这些线程共享进程的资源。 并发与并行：并发是指多个任务在逻辑上同时发生，而并行是指多个任务在物理上同时发生（例如...
新一代 Visual C++2005程序设计 part2
02-24
18.4 同步（Synchronization） 457 18.4.1 Critical Section 459 18.4.2 等待对象的状态改变 462 18.4.3 Mutex 463 18.4.4 Event 465 18.5 进程间通信（IPC） 468 18.5.1 共享内存与文件映射 468 18.6 ...
操作系统c语言两个进程制约且互斥,猿考研之操作系统篇三（进程同步，管程，死锁）...
weixin_39882394的博客
05-24 465
进程同步进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。同步机制应遵循的准则空闲让进：其他进程均不处于临界区；忙则等待：已有进程处于其临界区；有限等待：等待进入临界区的进程不能"死等"；让权等待：不能进入临界区的进程，应释放CPU(如转换到等待状态)进程互斥进程的“并发”需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源(比如内存，又比如打...
现代操作系统——多处理机系统
yw8355507的专栏
01-11 1116
前言：      本文转载自http://blog.csdn.net/courtneygeng/article/details/9997143 和梦无的博客。 这一章的内容大部分都是理论记忆知识，现在对于我来说了解还太少，不能深入理解。再对着书本抄一遍意义不太大，因此选择已有的博客来记录学习的过程。 我的github： 我实现的代码全部贴在我的github中，欢迎大家去参
【体系结构系列】同步实现
菜鸡也有大佬梦
12-27 695
同步实现 核心就是硬件提供原子操作指令 基本硬件原语 在多处理机中实现同步，所需的主要功能是： 一组能以原子操作的方式读出并修改存储单元的硬件原语。 它们都能以原子操作的方式 读+修改 存储单元 并指出所进行的操作是否以原子的方式进行。 通常情况下，用户不直接使用基本的硬件原语，原语主要提供程序员编制同步函数库 典型操作 原子交换 功能：将一个存储单元的值和一个寄存器的值进行交换。 建立一个锁，锁值： 0 ： 表示开的（可用） 1 ： 表示已上锁（不可用） 处理器上锁时，将对应
解决临界区（互斥）的软件方法-Dekker算法和Peterson算法
静水流深
11-29 5324
Dekker算法初步设想【保证了互斥】：让两个进程共享一个全局变量turn，【其初值为0或1】。如果turn==i，那么进程Pi允许在其临界区内执行。 —为了控制两个进程互斥进入临界区，可以让两个进程轮流进入临界区。 —当一个进程正在临界区执行时，另一个进程就不能进入临界区，而在临界区外等待。 1.为何是“强制交替”？ Turn=0时，无论CS空闲与否，即使P1就绪想要进入CS也【不会成
Data Synchronization数据同步
08-09
回答: 数据同步是指将不同数据源之间的...为了防止竞争条件，需要同步并发进程。数据同步通常需要使用其他组件(如MQ、JOB)进行配合，并且需要有规范的数据库支持。在进行数据同步之前，还需要对遗留数据进行集中治理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值