精华内容
下载资源
问答
  • 进程同步控制

    2018-11-30 16:37:00
    锁——multiprocessing.Lock 什么是锁? 当多个进程使用同一份数据资源的时候,...我们可以引用Lock模块来帮我们来实现将异步执行的程序在加锁的代码段中同步去执行。 mport os import time import random...

    锁——multiprocessing.Lock

    什么是锁?

    当多个进程使用同一份数据资源的时候,会引发数据安全或顺序混乱问题。这个时候我们希望进程可以一个一个的去获取和修改数据,将几个并发的进程编程串行,这样就可以保证数据的安全。我们可以引用Lock模块来帮我们来实现将异步执行的程序在加锁的代码段中同步去执行。

    mport os
    import time
    import random
    from multiprocessing import Process
    
    def work(n):
        print('%s: %s is running' %(n,os.getpid()))
        time.sleep(random.random())
        print('%s:%s is done' %(n,os.getpid()))
    
    if __name__ == '__main__':
        for i in range(3):
            p=Process(target=work,args=(i,))
            p.start()
    多进程抢占输出资源
    # 由并发变成了串行,牺牲了运行效率,但避免了竞争
    import os
    import time
    import random
    from multiprocessing import Process,Lock
    
    def work(lock,n):
        lock.acquire()
        print('%s: %s is running' % (n, os.getpid()))
        time.sleep(random.random())
        print('%s: %s is done' % (n, os.getpid()))
        lock.release()
    if __name__ == '__main__':
        lock=Lock()
        for i in range(3):
            p=Process(target=work,args=(lock,i))
            p.start()
    
    使用锁维护执行顺序
    使用锁来维护执行顺序

    上面这种情况虽然使用加锁的形式来实现了顺序的执行, 但是程序由并发编程串行了。这样虽然降低了效率,却保证了数据的安全。

     

    模拟抢票,来看看数据安全的重要性。

    #文件db的内容为:{"count":1}
    #注意一定要用双引号,不然json无法识别
    #并发运行,效率高,但竞争写同一文件,数据写入错乱
    from multiprocessing import Process,Lock
    import time,json,random
    def search():
        dic=json.load(open('db'))
        print('\033[43m剩余票数%s\033[0m' %dic['count'])
    
    def get():
        dic=json.load(open('db'))
        time.sleep(0.1) #模拟读数据的网络延迟
        if dic['count'] >0:
            dic['count']-=1
            time.sleep(0.2) #模拟写数据的网络延迟
            json.dump(dic,open('db','w'))
            print('\033[43m购票成功\033[0m')
    
    def task():
        search()
        get()
    
    if __name__ == '__main__':
        for i in range(100): #模拟并发100个客户端抢票
            p=Process(target=task)
            p.start()
    多进程同时抢购余票
    #文件db的内容为:{"count":5}
    #注意一定要用双引号,不然json无法识别
    #并发运行,效率高,但竞争写同一文件,数据写入错乱
    from multiprocessing import Process,Lock
    import time,json,random
    def search():
        dic=json.load(open('db'))
        print('\033[43m剩余票数%s\033[0m' %dic['count'])
    
    def get():
        dic=json.load(open('db'))
        time.sleep(random.random()) #模拟读数据的网络延迟
        if dic['count'] >0:
            dic['count']-=1
            time.sleep(random.random()) #模拟写数据的网络延迟
            json.dump(dic,open('db','w'))
            print('\033[32m购票成功\033[0m')
        else:
            print('\033[31m购票失败\033[0m')
    
    def task(lock):
        search()
        lock.acquire()
        get()
        lock.release()
    
    if __name__ == '__main__':
        lock = Lock()
        for i in range(100): #模拟并发100个客户端抢票
            p=Process(target=task,args=(lock,))
            p.start()
    使用锁来保证数据安全

    总结:

    加锁可以保证多个进程修改同一块数据时, 同一时间只能有一个任务可以进行修改, 即串行的修改。牺牲效率却保证了数据安全。

    虽然可以用文件共享数据实现进程间通信:

    1. 效率低(共享数据基于稳健, 而文件是硬盘的数据)
    2. 需要自己加锁处理

    因此我们最好寻找一种解决方案能够兼顾:

    1. 效率高(多个进程共享一块内存的数据)
    2. 帮我们处理好锁问题。

    这就是multiprocessing模块为我们提供的基于消息的IPC通信机制:队列和管道。

    队列和管道都是将数据存放在内存中

    队列又是基于(管道+锁)实现的,可以让我们从复杂的锁问题中解脱出来。

    我们应该尽量避免使用共享数据, 尽可能使用消息传递和队列, 避免处理复杂的同步和锁问题, 而且在进程数目增多时, 往往可以获得更好的可拓展性。

     

    信号量——multiprocessing.Semaphore(了解)

    信号量概念介绍:

    互斥锁同时只允许一个线程更改数据,而信号量Semaphore是同时允许一定数量的线程更改数据 。
    假设商场里有4个迷你唱吧,所以同时可以进去4个人,如果来了第五个人就要在外面等待,等到有人出来才能再进去玩。
    实现:
    信号量同步基于内部计数器,每调用一次acquire(),计数器减1;每调用一次release(),计数器加1.当计数器为0时,acquire()调用被阻塞。这是迪科斯彻(Dijkstra)信号量概念P()和V()的Python实现。信号量同步机制适用于访问像服务器这样的有限资源。
    信号量与进程池的概念很像,但是要区分开,信号量涉及到加锁的概念

    代码示例:
    from multiprocessing import Process,Semaphore
    import time,random
    
    def go_ktv(sem,user):
        sem.acquire()
        print('%s 占到一间ktv小屋' %user)
        time.sleep(random.randint(0,3)) #模拟每个人在ktv中待的时间不同
        sem.release()
    
    if __name__ == '__main__':
        sem=Semaphore(4)
        p_l=[]
        for i in range(13):
            p=Process(target=go_ktv,args=(sem,'user%s' %i,))
            p.start()
            p_l.append(p)
    
        for i in p_l:
            i.join()
        print('============》')
    
    例子
    信号量代码示例

     

     

    事件——multiprocessing.Event(了解)

    概念及方法介绍:

    python进程的事件主要提供了四个方法:

    set(), wait(), clear(), is_set()

    事件处理的机制: 全局定义了一个"Flag", 如果"Flag"值为False, 那么当程序执行event.wait()方法时就会阻塞, 如果"Flag"值为Ture, 那么event.wait()方法时便不再阻塞.

    事件的初始"Flag"状态为False

    clear: 将"Flag"设置为False

    set: 将"Flag"设置为True

    is_set: 查看"Flag"状态

    from multiprocessing import Process, Event
    import time, random
    
    
    def car(e, n):
        while True:
            if not e.is_set():  # 进程刚开启,is_set()的值是Flase,模拟信号灯为红色
                print('\033[31m红灯亮\033[0m,car%s等着' % n)
                e.wait()    # 阻塞,等待is_set()的值变成True,模拟信号灯为绿色
                print('\033[32m车%s 看见绿灯亮了\033[0m' % n)
                time.sleep(random.randint(3, 6))
                if not e.is_set():   #如果is_set()的值是Flase,也就是红灯,仍然回到while语句开始
                    continue
                print('车开远了,car', n)
                break
    
    
    def police_car(e, n):
        while True:
            if not e.is_set():# 进程刚开启,is_set()的值是Flase,模拟信号灯为红色
                print('\033[31m红灯亮\033[0m,car%s等着' % n)
                e.wait(0.1) # 阻塞,等待设置等待时间,等待0.1s之后没有等到绿灯就闯红灯走了
                if not e.is_set():
                    print('\033[33m红灯,警车先走\033[0m,car %s' % n)
                else:
                    print('\033[33;46m绿灯,警车走\033[0m,car %s' % n)
            break
    
    
    
    def traffic_lights(e, inverval):
        while True:
            time.sleep(inverval)
            if e.is_set():
                print('######', e.is_set())
                e.clear()  # ---->将is_set()的值设置为False
            else:
                e.set()    # ---->将is_set()的值设置为True
                print('***********',e.is_set())
    
    
    if __name__ == '__main__':
        e = Event()
        for i in range(10):
            p=Process(target=car,args=(e,i,))  # 创建是个进程控制10辆车
            p.start()
    
        for i in range(5):
            p = Process(target=police_car, args=(e, i,))  # 创建5个进程控制5辆警车
            p.start()
        t = Process(target=traffic_lights, args=(e, 10))  # 创建一个进程控制红绿灯
        t.start()
    
        print('============》')
    
    红绿灯实例
    代码示例

     

     

     

    转载于:https://www.cnblogs.com/af1y/p/10041203.html

    展开全文
  • 1. 进程控制 系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行,这样就组成了进程间的父子关系。 进程的创建 1)一个进程创建另一进程的事件(原因) 用户登录:分时情况下用户的请求...

    进程控制

    系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行,这样就组成了进程间的父子关系。
    在这里插入图片描述

    • 进程的创建
      1)一个进程创建另一进程的事件(原因)
      用户登录:分时情况下用户的请求
      *作业调度:批处理中
      *提供服务:运行中的用户程序提出功能请求,要创建服务进程(如打印服务)
      *应用请求:应用程序自己创建进程,完成特定功能的新进程。(木马程序)
      2)创建过程
      (1) 申请空白PCB;
      (2) 为新进程分配资源;
      主要是内存资源的处理;
      (3) 初始化进程控制块;
      标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。
      (4) 将新进程插入就绪队列。

    以上(1) 申请空白PCB
    (2) 为新进程分配资源
    主要是内存资源的处理
    (3) 初始化进程控制块
    标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。
    (4) 将新进程插入就绪队列
    <以上不能被打断!!!>
    原语是由若干指令构成的原子操作过程,作为整体实现功能,不可被打断

    • 进程的终止
      1)引起进程终止的事件
      *正常结束
      *异常结束
      **内存越界错误
      **保护错(权限错,如修改只读文件等)
      **非法指令(不存在的指令,程序异常转向而把数据当指令)
      **特权指令错(用户态程序试图执行只有OS可执行的指令)
      **运行超时、运算错、i/o故障等
      *外界干预
      **操作员或操作系统干预(死锁时,可人为结束)
      **父进程请求终止子进程
      **父进程终止,子孙进程也跟着终止
      2)终止过程
      (1) 根据进程标示符,检索出该进程PCB,读其状态。
      *IF 执行态,立即终止该进程,置调度标志为真,指示重新进行调度。
      *IF 有子孙进程,亦应予以终止,以防成为不可控进程。
      (2) 归还全部资源至其父进程或系统。
      (3) 将该进程PCB从所在队列或链表中移出。

    • 进程的阻塞与唤醒

    • 进程的挂起和激活

    展开全文
  • 进程控制同步

    2018-09-27 11:30:56
    进程控制 进程控制的基本过程: *进程的创建 *进程的终止 *进程的阻塞与唤醒 *进程的挂起和激活 关于进程的亲属关系 系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行, 这样就组成了进程间的...

    进程控制

    进程控制的基本过程:
    *进程的创建
    *进程的终止
    *进程的阻塞与唤醒
    *进程的挂起和激活

    关于进程的亲属关系

    系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行,
    这样就组成了进程间的父子关系。

    可用 “进程图”描述一个进程的家族关系,该图实际就是一种有向树。
    进程树示例

    • 感受进程及进程树

    1.“运行”——输入“cmd”,启动命令行控制台
    2.在cmd窗口输入“notepad”启动记事本。
    3.现在进程“cmd.exe”和进程“notepad.exe”就组成了一个进程树,后者为子进程,前者为父进程。
    4.用“任务管理器”在“进程”页,右击cmd.exe选择“结束进程树”。则记事本子进程也会结束。

    注:一些木马服务端程序运行后会同时生成两个木马进程,这两个进程互相监控、互相保护。对此类木马,我们就可以分别对两个木马进程尝试使用“结束进程树”命令。

    进程间的父子关系关系着资源的继承。创建和撤销进程时,其父、子进程要相应的被影响。

    1.进程的创建
    1)一个进程创建另一进程的事件(原因)

    *用户登录:分时情况下用户的请求
    *作业调度:批处理中
    *提供服务:运行中的用户程序提出功能请求,要创建服务进程(如打印服务)
    *应用请求:应用程序自己创建进程,完成特定功能的新进程。(木马程序)

    2)创建过程

    (1) 申请空白PCB
    (2) 为新进程分配资源
    主要是内存资源的处理
    (3) 初始化进程控制块
    标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。
    (4) 将新进程插入就绪队列

    原语是由若干指令构成的原子操作过程,作为整体实现功能,不可被打断。

    *OS通过调用进程创建原语Creat()创建新进程。

    *其他各控制工作也都是由OS内核以“原语”的方式实现,以保证不被打断。

    2.进程的终止
    1)引起进程终止的事件

    *正常结束

    *异常结束
    内存越界错误
    保护错(权限错,如修改只读文件等)
    非法指令(不存在的指令,程序异常转向而把数据当指令)
    特权指令错(用户态程序试图执行只有OS可执行的指令)
    运行超时、运算错、i/o故障等

    *外界干预
    操作员或操作系统干预(死锁时,可人为结束)
    父进程请求终止子进程
    父进程终止,子孙进程也跟着终止

    2)终止过程
    对上述事件,OS调用内核终止原语,执行下列过程:
    (1) 根据进程标示符,检索出该进程PCB,读其状态。
    *IF 执行态,立即终止该进程,置调度标志为真,指示重新进行调度。
    *IF 有子孙进程,亦应予以终止,以防成为不可控进程。
    (2) 归还全部资源至其父进程或系统。
    (3) 将该进程PCB从所在队列或链表中移出。

    3.进程的阻塞与唤醒
    1)引起进程阻塞和唤醒的事件

    *请求系统服务的满足情况
    *启动某种需等待(I/O)操作
    *合作需要的新数据尚未到达
    *执行某功能的进程暂时无新工作可做(如发送数据进程)

    2)阻塞和唤醒过程
    由进程调用阻塞原语阻塞自己,是主动行为:
    (1)将PCB中的状态改为阻塞
    (2)该PCB加入到阻塞队列中
    (3)转进程调度,将处理机分配给另一进程
    (4)进行进程切换,即根据两切换进程的PCB,保护与重新设置处理机状态。

    阻塞与唤醒原语作用相反,成对使用

    阻塞进程等待的事件发生时,有关进程(如放弃该资源的进程)调用唤醒原语把等待该事件的进程唤醒。
    (1)把阻塞进程从等待该事件的阻塞队列中移出
    (2)将其PCB中的现行状态改为就绪
    (3)将PCB插入到就绪队列中。

    4.进程的挂起与激活

    挂起原语将指定进程或阻塞进程挂起。
    (1)检查被挂起进程的状态,活动就绪则改为静止就绪,活动阻塞则改为静止阻塞
    (2)将该PCB复制到内存(方便检查)/外存(对换)指定区域
    (3)*若挂起的进程是执行态,则需重新进行进程调度。
    注意:进程只能挂起自己或其子孙进程。

    激活原语的执行过程
    若挂起进程在外存上,将其调入内存
    检查进程状态,若处于静止就绪,则改为活动就绪,若处于静止阻塞,则改为活动阻塞

    关于调度

    *进程控制中,状态转换和调度密切相关。
    *运行态进程的改变必然产生调度行为
    *只要产生新就绪态进程,就需考虑调度策略
    *只要是采用抢占式调度,要检查新就绪进程是否可抢占CPU,引起新的调度。

    控制并发:

    基本控制
    进程、PCB、状态、基本控制过程

    合理控制
    控制进程的相互影响,得到可再现的正确结果

    进程间两种制约关系:

    1.间接相互制约关系:主要源于资源共享,表现为
    进程A—打印机资源—进程B(互斥)

    2.直接相互制约关系:主要源于进程合作,表现为
    进程A写缓冲—进程B读缓冲(有序)

    1.进程同步的基本概念
    1)进程同步的主要任务:
    使并发执行的诸进程之间能有效地共享资源和相互合作,
    从而使程序的执行具有可再现性。

    2)临界资源
    一次仅允许一个进程使用的资源。

    3)临界区
    每个进程中访问临界资源的那段代码叫临界区。
    为了正确同步,对临界区的代码要增加控制

    进入区:对欲访问的临界资源进行检。若此刻未被访问,设正在访问的标志
    临界区:访问临界资源的代码。
    退出区:将正在访问的标志恢复为未被访问的标志
    剩余区:其余部分

    4)同步机制应遵循的规则

    实现互斥的方法应符合如下每条原则

    空闲让进:资源使用最基本原则
    忙则等待:保证互斥
    有限等待:合适时被唤醒防止死等
    让权等待:能主动释放CPU防止忙等

    同步控制的关键
    主要涉及”判断”和”修改标志”操作
    不应被打断(原语,OS核心态运行)

    硬件同步机制
    *许多计算机提供一些特殊的硬件指令,允许对一个字中的内容进行检测和修正,
    或对两个字的内容进行交换。利用这些特殊指令解决临界区问题。
    *进入临界区往往跟其标志有关,可将标志看做一个锁,“锁开”进入并关锁,
    “锁关”必须等待,初始时锁是打开的。

    (1)关中断

    *进入锁测试前关闭中断,直到完成锁测试并上锁后才能打开中断。
    进程在临界区执行期间,系统不响应中断,从而不引发调度。

    *缺点:
    *滥用风险
    *关中断时间过长会影响效率,限制CPU交叉执行能力
    *不适用于多CPU系统

    (2)Test-and-Set指令
    boolean TS(boolean *lock)
    {
    Boolean old;
    old=*lock;
    *lock=TRUE;
    return old;
    }
    *一个不可分割的原语

    为一个临界资源设置一布尔变量lock,初值为false
    do{

    while TS(&lock) ;
    critical section;
    lock=FALSE;
    remainder section;
    }while(TRUE);

    (3)利用Swap指令实现进程互斥

    *对换指令(intel 80x86中称XCHG指令),用于交换两个字节的内容
    void swap(boolean *a, boolean *b)
    {boolean temp;
    temp=*a;
    *a=*b;
    *b=temp;
    }

    *为临界资源设置一个全局布尔变量lock=false。每个进程一个局部布尔变量key。
    do{
    key=TRUE;
    do{
    swap(&lock,&key);
    }while(key!=FALSE);
    临界区操作;
    lock=FALSE;
    剩余区;
    }while(TRUE);

    完全利用软件方法,有很大局限性,也不适于多进程,现在已很少采用。
    硬件指令机械操作可保证锁开、关操作不被打断;适用于任意数目的进程。
    但等待要耗费CPU时间,不能实现“让权等待”,从等待进程中随机选择一个进入临界区,
    有的进程可能一直选不上,难以实现较为复杂的进程同步问题。

    展开全文
  • 进程控制 1.进程的创建 1)一个进程创建另一进程的事件(原因) 用户登录:分时情况下用户的请求 作业调度:批处理中 提供服务:运行中的用户程序提出功能请求,要创建服务进程(如打印服务) 应用请求:应用...

    进程控制
    1.进程的创建
    1)一个进程创建另一进程的事件(原因)
    用户登录:分时情况下用户的请求
    作业调度:批处理中
    提供服务:运行中的用户程序提出功能请求,要创建服务进程(如打印服务)
    应用请求:应用程序自己创建进程,完成特定功能的新进程。(木马程序)
    2)创建过程
    (1) 申请空白PCB
    (2) 为新进程分配资源
    主要是内存资源的处理
    (3) 初始化进程控制块
    标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。
    (4) 将新进程插入就绪队列
    原语是由若干指令构成的原子操作过程,作为整体实现功能,不可被打断。
    OS通过调用进程创建原语Creat()创建新进程。
    其他各控制工作也都是由OS内核以“原语”的方式实现,以保证不被打断
    2.进程的终止
    1)引起进程终止的事件
    正常结束
    异常结束
    内存越界错误
    保护错(权限错,如修改只读文件等)
    非法指令(不存在的指令,程序异常转向而把数据当指令)
    特权指令错(用户态程序试图执行只有OS可执行的指令)
    运行超时、运算错、i/o故障等
    外界干预
    操作员或操作系统干预(死锁时,可人为结束)
    父进程请求终止子进程
    父进程终止,子孙进程也跟着终止
    2)终止过程
    对上述事件,OS调用内核终止原语,执行下列过程:
    (1) 根据进程标示符,检索出该进程PCB,读其状态。
    *IF 执行态,立即终止该进程,置调度标志为真,指示重新进行调度。
    *IF 有子孙进程,亦应予以终止,以防成为不可控进程。
    (2) 归还全部资源至其父进程或系统。
    (3) 将该进程PCB从所在队列或链表中移出。
    3.进程的阻塞与唤醒
    1)引起进程阻塞和唤醒的事件
    请求系统服务的满足情况
    启动某种需等待(I/O)操作
    合作需要的新数据尚未到达
    执行某功能的进程暂时无新工作可做(如发送数据进程)
    2)阻塞和唤醒过程
    由进程调用阻塞原语阻塞自己,是主动行为:
    (1)将PCB中的状态改为阻塞
    (2)该PCB加入到阻塞队列中
    (3)转进程调度,将处理机分配给另一进程
    (4)进行进程切换,即根据两切换进程的PCB,保护与重新设置处理机状态。
    阻塞进程等待的事件发生时,有关进程(如放弃该资源的进程)调用唤醒原语把等待该事件的进程唤醒。
    (1)把阻塞进程从等待该事件的阻塞队列中移出
    (2)将其PCB中的现行状态改为就绪
    (3)将PCB插入到就绪队列中。
    4.进程的挂起与激活
    挂起原语将指定进程或阻塞进程挂起。
    (1)检查被挂起进程的状态,活动就绪则改为静止就绪,活动阻塞则改为静止阻塞
    (2)将该PCB复制到内存(方便检查)/外存(对换)指定区域
    (3)*若挂起的进程是执行态,则需重新进行进程调度。
    激活原语的执行过程
    若挂起进程在外存上,将其调入内存
    检查进程状态,若处于静止就绪,则改为活动就绪,若处于静止阻塞,则改为活动阻塞

    进程同步
    进程间的两种制约关系:
    1、间接相互制约关系:主要源于资源共享,表现为
    进程A—打印机资源—进程B(互斥)
    2、直接相互制约关系:主要源于进程合作,表现为
    进程A写缓冲—进程B读缓冲(有序)
    1.进程同步的基本概念
    1)进程同步的主要任务:
    使并发执行的诸进程之间能有效地共享资源和相互合作,从而使程序的执行具有可再现性。
    2)临界资源
    一次仅允许一个进程使用的资源。
    3)临界区
    每个进程中访问临界资源的那段代码叫临界区。
    为了正确同步,对临界区的代码要增加控制。
    进入区:对欲访问的临界资源进行检。若此刻未被访问,设正在访问的标志
    临界区:访问临界资源的代码。
    退出区:将正在访问的标志恢复为未被访问的标志
    剩余区:其余部分
    4)同步机制应遵循的规则
    实现互斥的方法应符合如下每条原则
    空闲让进:资源使用最基本原则
    忙则等待:保证互斥
    有限等待:合适时被唤醒防止死等
    让权等待:能主动释放CPU防止忙等
    同步控制的关键
    主要涉及”判断”和”修改标志”操作
    不应被打断(原语,OS核心态运行)
    硬件同步机制
    许多计算机提供一些特殊的硬件指令,允许对一个字中的内容进行检测和修正,或对两个字的内容进行交换。利用这些特殊指令解决临界区问题。
    进入临界区往往跟其标志有关,可将标志看做一个锁,“锁开”进入并关锁,“锁关”必须等待,初始时锁是打开的。
    ①关中断
    进入锁测试前关闭中断,直到完成锁测试并上锁后才能打开中断。进程在临界区执行期间,系统不响应中断,从而不引发调度。
    缺点:
    滥用风险
    关中断时间过长会影响效率,限制CPU交叉执行能力
    不适用于多CPU系统
    ②Test-and-Set指令
    boolean TS(boolean *lock)
    {
    Boolean old;
    old=*lock;
    *lock=TRUE;
    return old;
    }
    *一个不可分割的原语

    为一个临界资源设置一布尔变量lock,初值为false
    do{

    while TS(&lock) ;
    critical section;
    lock=FALSE;
    remainder section;
    }while(TRUE);
    ③利用Swap指令实现进程互斥
    对换指令(intel 80x86中称XCHG指令),用于交换两个字节的内容
    void swap(boolean *a, boolean *b)
    {boolean temp;
    temp=*a;
    *a=*b;
    *b=temp;
    }
    为临界资源设置一个全局布尔变量lock=false。每个进程一个局部布尔变量key。
    do{
    key=TRUE;
    do{
    swap(&lock,&key);
    }while(key!=FALSE);
    临界区操作;
    lock=FALSE;
    剩余区;
    }while(TRUE);

    2.信号量机制
    1) 整型信号量
    最初的信号量机制,两个原子操作对一个共享整型量进行操作。
    信号量定义为一个整型量;
    根据初始情况赋相应的值;
    仅能通过两个原子操作来访问。
    在这里插入图片描述

    展开全文
  • multiprocessing包—Process模块...进程同步控制—multiprocessing.Lock multiprocessing.Semaphore multiprocessing.Event 进程间通信(IPC)— multiprocessing.Pipe multiprocessing.Queue 进程间的数据共享 —...
  • Catalogue 进程控制与同步进程控制的基本过程进程的创建进程的终止引起终止的事件进程的阻塞与唤醒进程的挂起和激活进程同步的主要任务:互斥同步互斥同步临界区同步机制应遵循的规则关中断缺点:整形信号量P操作V...
  • 代码:#include #include#include#include/*************基本的函数API********************1-pid funcpid_t getpid(void)pid_t fork(void)fork函数创建的字进程是父进程的副本,执行的是与父进程完全相同的程序,...
  • 进程同步 问题:多道程序并发执行,不确定性,结果不可再现 解决:进程同步机制——硬件同步机制、信号量机制、管程机制 4.1 进程同步基本概念 进程同步机制的主要任务:协调多个相关进程的执行顺序,按照一定...
  • 基于模型预测控制的多进程系统同步控制方案
  • 进程同步控制

    2018-07-25 16:48:00
    1.进程中间的数据是隔离的 1.1经常与经常之间是不能自由的交换内存数据的 1.2全局的变量在子进程中修改,主进程和其他进程是感知不到而且不变的2.守护进程 2.1 特点 生命周期只有和主经常的代码有关系,和其他子...
  • 2.2 进程控制 进程控制的基本过程: 进程的创建 进程的终止 进程的阻塞与唤醒 进程的挂起和激活 关于进程的亲属关系: 系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行,这样就组成了...
  • 进程控制同步

    2019-09-29 01:00:53
    1、进程控制 1、进程的创建 (1) 申请空白PCB(2) 为新进程分配资源主要是内存资源的处理(3) 初始化进程控制块标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。(4) 将新进程插入...
  • 文章目录2.4 进程同步2.4.1 进程同步的基本概念1、两种制约关系2、临界资源3、临界区4、同步机制应遵循的规则练习题练习题2.4.2 实现互斥的软硬件方法算法1算法2算法3算法4练习题硬件设施练习题练习题2.4.3 信号量...
  • 1.进程控制的概念 2.进程的创建 3.进程间互斥与同步的概念 4.临界资源和临界区 5.同步机制应遵循的原则 6.信号量与P/V操作 7.生产者与消费者问题 1.进程控制的概念 进程由创建产生,由调度执行,由撤销消亡...
  • 当多个进程使用同一份数据资源的时候,就会引发数据安全或顺序混乱问题加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改lock=Lock() lock.acquire() # 拿钥匙进门 lock....
  • 1.进程控制的基本过程 进程的创建 (1) 申请空白PCB (2) 为新进程分配资源  主要是内存资源的处理 (3) 初始化进程控制块  标识符(包括父进程的)、程序计数器指向程序入口地址,就绪态、优先级等信息的填写。...
  • 2.2 进程控制 进程控制的基本过程: 进程的创建 进程的终止 进程的阻塞与唤醒 进程的挂起和激活 系统中运行的进程并不都是孤立的,有的进程运行后,会调用其他进程来执行,这样就组成了进程间的父子关系。 ...
  • 处理机管理的主要功能有:创建和撤销进程,对诸进程的运行进行协调,实现进程之间的信息交换,以及按照一定的算法将处理机分配给进程。 在多道程序环境下为使作业能并发执行,必须为每道作业创建一个或
  • 文章目录2.4 进程同步2.5 经典的进程同步问题2.6 管程2.7 进程通信2.8 线程及其实现2.9 本章要点与课堂练习 2.4 进程同步 2.5 经典的进程同步问题 2.6 管程 2.7 进程通信 2.8 线程及其实现 2.9 本章要点与课堂练习 ...
  • 定义:前驱图是一个有向无循环图(DAG),用于描述进程之间执行的相互关系。 组成:每个结点表示一条语句,一个进程或程序段。结点间的有向边表示两结点间存在的前驱或偏序关系,用箭头表示。 注意前驱图中不能...
  • 2.2进程控制 基本过程: 进程的创建 进程的终止 进程的阻塞与唤醒 进程的挂起和激活 1、进程的创建 1)一个进程创建另一进程的事件(原因)  用户登录:分时情况下用户的请求 作业调度:批处理中 提供服务:...
  • 进程同步: 基本概念: 两种形式制约关系: 临界资源: 生产者--消费者问题: 同步机制规则: 信号量机制: 进程的描述: 进程的定义: 多道程序的环境下,程序的执行属于并发执行,此时他们讲失去...
  • 在多任务操作系统环境下,进程和线程的同步控制是多线程和多进程编程的一个重点,稍作总结  一、临界区(criticalsection)  1、临界区是线程同步的一种方式,即它在同一时刻只允许一个线程进入,其他线程只能等...
  • 进程的创建过程 创建:1、申请空白pcb 2、分配新进程所需要的资源 3、初始化pcb 4、将进程插入就绪队列 终止:1、根据进程标识符找到pcb并读取其状态信息。if 执行态,立即终止其执行,将调度标志置为...
  • 进程控制

    2015-10-18 22:23:07
    进程的内存开销:系统必须为每个进程建立进程控制快pcb,通常常驻内存,此外,为了协调并发运行,系统还要进行进程管理机构,解决同步互斥,死锁问题,会占用可观的内存空间 进程的时间开销:在内存切换时,系统要...
  • from multiprocessing import Process , current_process , Semaphore def funca(args): # args 参数是实例化的Semaphoer ... # Semaphoer实例的acquire()方法,给本进程枷锁,其他进程不能执行 args.acquire()...

空空如也

空空如也

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

进程控制进程同步