精华内容
下载资源
问答
  • 简要描述临界资源、临界区及互斥同步机制的原则 答: ①临界资源:指每次只允许一个进程访问的资源,分为硬件、软件临界资源。 ②临界区:每个进程中访问临界资源的那段程序,进程对临界区访问必然相反,每次仅...

    简要描述临界资源、临界区及互斥同步机制的原则

    答:
    临界资源:指每次只允许一个进程访问的资源,分为硬件、软件临界资源。
    临界区:每个进程中访问临界资源的那段程序,进程对临界区的访问必然相反,每次仅允许一个进程进入临界区,其它进程等待。
    互斥同步原则:

    1、空闲等待:当没有进程进入临界区时,相应的临界资源处于空闲状态,因而允许一个请求进入临界区的进程立即进入自己的临界区;
    2、忙则等待:当已有进程进入自己的临界区时,即相应的临界资源正被访问,因而其它试图进入临界区的进程必然等待,以保证进程互斥地访问临界资源;
    3、有限等待:对要求访问临界资源的进程,应当保证进程能够在有限时间进入临界区,以免陷入“死等”状态;
    4、让权等待:当进程不能进入自己的临界区时应当释放处理机,以免进程陷入“忙等”状态。

    展开全文
  • 当有一个进程在临界区是,其他需要进入临界区的进程必须等待,以保证进程互斥地访问临界资源。 有限等待。对要求访问临界资源的进程,应保证进程等待有限时间后进入临界区,以免陷入“饥饿”状态。 让权等待。当进程...
    1. 有空即进。当无进程处于临界区时,允许进程进入临界区,并且只能在临界区运行有限的时间。
    2. 无空则等。当有一个进程在临界区是,其他需要进入临界区的进程必须等待,以保证进程互斥地访问临界资源。
    3. 有限等待。对要求访问临界资源的进程,应保证进程等待有限时间后进入临界区,以免陷入“饥饿”状态。
    4. 让权等待。当进程不能进入自己的临界区时,应立即释放处理机,以免进程陷入“忙等”状态。
    展开全文
  • 进程互斥访问临界区

    千次阅读 2019-10-21 20:17:35
    1、空闲让进:临界区空闲时应该允许一个进程访问; 2、忙则等待:临界区访问时,其余想访问他的进程必须等待; 3、有限等待:等待的进程在外等待的时间必须是有限的; 4、让权等待:若等待进程一直等待,迟迟进...

    进程对临界资源的访问需要互斥,其需要遵从以下四个原则:

    1、空闲让进:临界区空闲时应该允许一个进程访问;

    2、忙则等待:临界区被访问时,其余想访问他的进程必须等待;

    3、有限等待:等待的进程在外等待的时间必须是有限的;

    4、让权等待:若等待进程一直等待,迟迟进不到临界区时,应该让出cpu处理机,防止忙等。

    下面将介绍三种经典的软件实现的算法:

    1、单标志法,使用一个标志位,标志此时访问临界区的进程,进入时先判断若另一进程未进入时才进去临界区,该进程访问完之后,把标志位转成另一进程,如此交替访问即可,用java的线程模拟该过程代码如下:

    public class OneFlagMutex {
         int turn = 0;
         public void m0() {
             while(turn != 0) {
                 System.out.println("m0正在等待");
             };
             System.out.println("m0在访问临界区");
             turn = 1;
         }
         public void m1() {
             while(turn != 1) {
                 System.out.println("m1正在等待");
             };
             System.out.println("m1在访问临界区");
             turn = 0;
         }
        public static void main(String[] args) {
            OneFlagMutex o = new OneFlagMutex();
            new Thread(new Runnable() {
                public void run() {
                    o.m0();
                }
            }).start();
            new Thread(()->{
                o.m1();
            }).start();; 
        }
    
    }
    

    该方法有一个最大的问题是,需要两个进程不断交替访问,当turn == 1时,若此时进程一不访问的话,进程0将一直得不到访问临界区的权限,从而违背了“空闲让进”原则。

    2.1、双标志先检查法:

    设置两个标志位,flag = [false,false],此时哪个进程进入了就把哪个位置上的flag置为true,大体算法如下:“先检查再加锁”,进入临界区时先检查另一进程是否进去,若未进去,则进入后立刻给把自己的位置置为true,访问完之后把自己的flag置为false。代码如下:

     class T{
         private boolean[] flag = {false,false};//表示各进程是否想进去临界区
         public void p0() {//p0访问临界区 
             while(flag[1]) {
                 System.out.println("p0在等待");
             };
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             flag[0] = true;
             System.out.println("p0在访问临界区");
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             System.out.println("p0访问完了");
             flag[0] = false;
         }
         public void p1() {
             while(flag[0]) {
                 System.out.println("p1在等待");
             };
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             flag[1] = true;
             System.out.println("p1在访问临界区");
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             System.out.println("p1访问完了");
             flag[1] = false;
         }
     }
     public class TwoFlagPredetect {
    
        public static void main(String[] args) {
            T t = new T();
            new Thread(()->{
                t.p0();
            }).start();
            new Thread(t::p1).start();
        }
    
    }
    

    当第一个进程经过检测进入临界区时,此时它还没来得及将自己的标志位置true加锁第二个进程获得处理机,如此第二个进程也进入了临界区了,如此违背了“忙则等待”的原则。

    2.2、双标志位后检查

    由于“先检测后加锁”使得两个进程都进入到了临界区,人们很自然的想到了一种“先加锁,再检测”的方法,大体与2.1类似,其代码如下:

    class P{
         private boolean[] flag = {false,false};
         public void p0() {
             flag[0] = true;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             while(flag[1]) {
                 System.out.println("p0在等待");
             };
             System.out.println("p0在访问临界区");
             try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                 e.printStackTrace();
            }
             flag[0] = false;
         }
         public void p1() {
             flag[1] = true;
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             while(flag[0]) {
                 System.out.println("p1在等待");
             };
             System.out.println("p1在访问临界区");
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                  e.printStackTrace();
             }
             flag[1] = false;
         }
     }
     public class TwoFlagAfterdetect {
    
        public static void main(String[] args) {
            P p = new P();
            new Thread(p::p0).start();
            new Thread(p::p1).start();
    
        }
    
    }
    

    该方法虽然解决了2.1的问题(违背“忙则等待”),但是当第一个进程刚加完锁,还没来得及进入临界区时,后面的进程获得了处理机,然后其也对自己的flag加上锁,于是便出现了0进程和1进程都只能再外面死等着。都进不去临界区。如此又违背了“空闲让进”和“有限等待”。

    3、Peterson算法

    该算法集单标志和双标志之长,在双标志后检查的基础上又添加了一个标志turn,当两个进程都想访问临界区时,其会将turn置为对方,让对方先访问有一个“孔融让梨”的机制。大体算法如下:当一个进程想访问临界区时,其会先进行争抢(把自己的flag置为true),再进行礼让(把turn置为对方),然后进行检测如若(另一进程的flag = true && turn = 另一进程)由于另一进程flag = true说明另一进程也想访问临界区,然后将礼让出去。

    实现代码如下:

     class Process implements Runnable{
         private static boolean[] flag = {false,false};
         private static int turn;
         private int id;
         public Process(int id) {
             this.id = id;
         }
        @Override
        public void run() {
             if(id == 0) {
                 flag[0] = true;//先争取
                 turn = 1; //再谦让
                 try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                     e.printStackTrace();
                }
                 while(flag[1] && turn == 1) {
                     System.out.println("进程0正在等待");
                 };
                 System.out.println("进程0正在访问临界区");
                 flag[0] = false;
             }else {
                 flag[1] = true;//先争取
                 turn = 0; //再谦让
                 while(flag[0] && turn == 0) {
                     System.out.println("进程1正在等待");
                 };
                 System.out.println("进程1正在访问临界区");
                 flag[1] = false;
             }
        }
         
     }
     public class PetersonA {
    
        public static void main(String[] args) {
            new Thread(new Process(0)).start();
            new Thread(new Process(1)).start();
        }
    
    }
    

    以上就是软件实现进程互斥访问的三个算法。但是这三个算法都违背了“有限等待”的原则,对于满足“有限等待”的新的算法将在后续的信号量中加以介绍。

     

    展开全文
  • 问题:违背空闲让进(当有一个线程结束,另外一个即使没有结束也无法进入临界区) public class SingleFlag { public static volatile boolean flag; public static volatile int num = 0; public static void ...

    0 同步机制遵循准则

    1. 空闲让进:临界区空闲时,允许请求进入临界区
    2. 忙则等待:有线程进入临界区时,其他线程必须等待
    3. 有限等待:等待不能无限制持续下去
    4. 让权等待:释放等待线程的 CPU 资源

    1 单标志

    问题:违背空闲让进(当有一个线程结束,另外一个即使没有结束也无法进入临界区)

    public class SingleFlag {
        public static volatile boolean flag;
        public static volatile int num = 0;
    
        public static void main(String[] args) {
            new Thread(() -> {
                while (true) {
                    while (flag) ;
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag = false;
                }
            }).start();
    
            new Thread(() -> {
                while (true) {
                    while (flag) ;
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag = true;
                }
            }).start();
        }
    }
    

    2 双标志先检查

    问题:违背忙则等待(恰好执行完 1 时线程切换,此时 2 判断也能通过,则会存在安全问题)

    public class DoubleFlag {
        public static volatile boolean[] flag={false, true};
        public static volatile int num = 0;
    
        public static void main(String[] args) {
            new Thread(() -> {
                while (true) {
                    while (flag[0]); // 1
                    flag[1] = true; 
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[1] = false;
                }
            }).start();
    
            new Thread(() -> {
                while (true) {
                    while (flag[1]); // 2
                    flag[0] = true; 
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[0] = false;
                }
            }).start();
        }
    }
    

    3 双标志后检查

    问题:违背有限等待原则(两个线程无限制谦让,导致活锁)

    public class DoubleFlagAfterCheck {
        public static volatile boolean[] flag = {false, true};
        public static volatile int num = 0;
    
        public static void main(String[] args) {
            new Thread(() -> {
                while (true) {
                    flag[1] = true; 
                    while (flag[0]);
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[1] = false;
                }
            }).start();
    
            new Thread(() -> {
                while (true) {
                    flag[0] = true; 
                    while (flag[1]);
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[0] = false;
                }
            }).start();
        }
    }
    

    4 Peterson

    完美解决并发安全性问题
    问题:无法达到让权等待(CPU 一直在死循环判断,占用 CPU 资源)

    public class Peterson {
        public static volatile boolean[] flag = {false, false};
        public static volatile int turn = 0;
        public static volatile int num = 0;
    
        public static void main(String[] args) {
            new Thread(() -> {
                while (true) {
                    flag[0] = true;
                    turn = 2;
                    while (flag[1] && turn == 2) ;
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[0] = false;
                }
    
            }).start();
    
            new Thread(() -> {
                while (true) {
                    flag[1] = true;
                    turn = 1;
                    while (flag[0] && turn == 1) ;
                    System.out.println(Thread.currentThread().getName() + " " + ++num);
                    flag[1] = false;
                }
            }).start();
        }
    }
    
    展开全文
  • Windows 进程进入临界区的调度原则

    千次阅读 2010-10-19 23:29:00
    进程进入临界区的调度原则是:  ①如果有若干进程要求进入空闲的临界区,一次仅允许一个进程进入。  ②任何时候,处于临界区内的进程不可多于一个。如已有进程进入自己的临界区,则其它所有试图...
  • 目录进程管理(实现临界区互斥的方法)一....进入区:检查是否可以进入临界区,若可以则设置正在访问临界区的标志(加锁),以阻止其他进程同时进入临界区 临界区:进程中访问临界资源的那段代码 退出区:解除正在访问临界资
  • 实现进程互斥需要遵循原则

    千次阅读 2019-04-10 21:33:26
    1.、空闲让进 当临界区空闲时,可以允许一个请求进入临界区的...对请求访问的进程,应保证能在有限时间内进入临界区(保证不会饥饿)。 4、让权等待 当进程不能进入临界区时,应立即释放处理机,防止进程忙等待。 ...
  • 进程同步的概念临界资源:许多硬件...临界区:人们把在每个进程中访问临界资源的那段代码称为临界区(critical section) repeat entry section critical section; exit section remainder section; until false;
  • 同步机制遵循原则

    千次阅读 2019-11-14 19:10:15
    进程在并发执行时为了保证结果的可再现性,各进程执行序列必须加以限制以保证互斥地使用临界资源,相互合作... 当无进程进入临界区时,相应的临界资源处于空闲状态,因而允许一个请求进入临界区的进程立即进入自己...
  • 实现临界区互斥的基本方法

    千次阅读 2018-01-04 18:55:55
     在进入区设置和检查一些标志来表明是否有进程在临界区中,如果已有进程在临界区,则在进入区通过循环检查进行等待,进程离开临界区后则在退出区修改  标志。  (1)、算法一:单标志法。(违背“空闲让进”...
  • 为避免对临界区并发访问,必须保证临界区代码被原子地执行。代码在执行期间不可被打断,如同整个临界区是一个不可分割的指令。如果两个内核任务处于同一个临界区中,这就是一种错误现象。如果确实发生这种情况,就...
  • 4 临界区(Critical section) 5 信号量与管程(Dijkstra提出的信号量) 6 死锁 7 进程间通信(IPC) 1 进程(process)描述 1.1 进程定义 一个具有一定独立功能的程序在一个数据集合上的一次 动态 执行过程。 ...
  • 1.背景   首先,看个例子,进程P1,P2公用一个变量COUNT,初始值为0    因为P1,P2两个进程的执行顺序是随机的,可能顺序执行也可能是并发的,由图可见,不同的... 像这种情况,及多个进程并发访问和操
  • 操作系统--问答题

    2021-07-18 02:31:31
    但所有的同步机制都应遵循下述4条准则: (1)空闲让进 :无进程处于临界区时,相应的临界资源处于空闲状态,因而可允许下个请求进入临界区的进程立即进入自己 的临界区,以有效地利用临界资源。 (2)忙则等待 : 己有进程...
  • A:对B:错Python类中包含一个特殊的变量(),它表示当前对象自身,可以访问类的成员.A:meB:selfC:thisD:与类同名在过火面积中,包括()。A:疏林地面积B:荒山荒地面积C:灌木林地面积D:有林地面积额面又称水平面,是与...
  •  当两个线程要访问同一个变量的时候,就会发生竞争,此时需要线程同步,线程同步的关键就是要解决临界区的问题。  解决竞争问题,要遵循下面的原则: 任何两个进程/线程不能同时处于临界区 不应该对 CPU 的...
  • 同步机制应遵循的准则

    千次阅读 2020-12-12 23:23:42
    ** 同步机制应遵循的准则 ** 空闲让进 临界区空闲时,可以允许一个请求...有限等待 对请求访问的进程,应保证能在有限时间内进入临界区 让权等待 当进程不能进入临界区时,应立即释放处理器,防止进程忙等待。 ...
  • 当已有进程处于临界区时,表面临界资源正在被访问,因而其他试图进入临界区的进程必须等待,以保证对临界资源的互斥访问 c. 有限等待.对要求访问临界资源的进程,应保证在有限时间内能进入自己的临界区,以免陷入...
  • 进程临界问题

    2016-08-04 03:05:24
    仔细分析上面两段代码可以知道当多进程执行代码时他们都违反了Progress原则临界区原则)。    Peterson算法代码如下:很好地满足了临界区原则。  利用了中间值turn,避开了。   pi进程 ...
  • 1 进程同步 2 进程互斥 2.1 四个部分(进入区、临界区、退出区、剩余区) 2.2 需要遵循原则(空闲让进、忙则等待、有限等待、ra)
  • 算法思想:两个进程早访问临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予。 实现同一时刻最多只允许一个进程访问临界区。 主要问题:不遵循“空闲让进”...
  • 临界区是一个可以被多个线程共享的区域,它内部存放的数据属于公共资源,但是访问或者修改该区域的数据,只能由一个线程来完成,其他的线程只能等待前面的线程访问或者修改完临界区数据后才可以继续访问或者修改。...
  • 数据库设计原则和优化

    千次阅读 2018-12-12 20:37:57
    数据库设计原则:   1. 原始单据与实体之间的关系   可以是一对一、一对多、多对多的关系。在一般情况下,它们是一对一的关系:即一张原始单据对应且只对应一个实体。  在特殊情况下,它们可能是一对多或多对...
  • 一.概念 临界资源:在一个时间段内只允许一个进程访问的资源叫做临界资源 ...临界区访问临界资源的那段代码 退出区:负责解除正在访问临界资源的标志(也就是给临界资源解锁) 剩余区:做其他处理 三
  • 1.进程同步的概念 在多道程序程序环境下,进程...临界区访问的四个部分:1)进入区;2)临界区;3)推出区;3)剩余区; 2)同步 同步亦是直接制约关系,源于进程之间的相互协作进程之间在某种任务中,协调...
  • 进程同步问题(一)

    2021-04-12 10:32:31
    一、进程同步的基本概念 在多道程序环境下,进程是并发执行的。不同进程之间存在不同的相互制约关系。为了协调进程之间的相互...临界资源 虽然多个进程可以共享系统中的各种资源,但其中许多资源一次只能为一个进程所用
  • 这种制约关系源于多个同种进程需要互斥地共享某种系统资源,互斥是设置在同种进程之间以达到互斥访问资源地目的 例如:生产者-消费者问题中,生产者与生产者之间需要互斥访地访问缓冲池。 直接相互制约关系(同步)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,584
精华内容 1,833
关键字:

临界区访问遵循的原则