并发编程-守护进程-互斥锁

电玩女神 2021-11-10 11:40 374阅读 0赞

# 守护进程 #

主进程创建守护进程(子进程)

那么主进程就是被守护进程

*  守护进程会在主进程代码执行结束后就终止
 *  守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children

**注意:进程之间是相互独立的,主进程代码运行结束,守护进程随即终止.**

from multiprocessing import Process
    import time
    
    def task():
        print('sub start')
        print('sub over')
    
    
    if __name__ == '__main__':
        p =Process(target=task)
        p.daemon = True  # 将这个进程设置成子进程,必须放在p.start()前面
        p.start()
        print('parent start')
        time.sleep(1)   # 这里加延时,就是为了让子进程运行完毕,否则,就会出现子进程(守护进程)还没有运行完全,主程序(被守护进程)就已经运行完并结束代码了
        print('parent over')
        
    # 如果没有在主程序这里加延时,则不会打印子进程,因为在操作系统开启子进程时,主程序代码已经运行完毕.   
    parent start
    sub start  
    sub over
    parent over

# 进程安全问题 #

因为子进程的内存时相互隔离的,所以进程之间数据不共享;如果多个在子进程同时访问同一个文件,或者打印同一个终端,那么就会带来竞争,竞争带来的结果就是错乱,这个就是进程安全问题.

这里进程1和进程2,之所以把范围放这么大,是为了能显示出问题打印

from multiprocessing import Process
    
    def task1():
        for i in range(10000):
            print('sub1 run')
            print('sub1  over')
    
    
    def task2():
        for i in range(10000):
            print('sub2 run')
            print('sub2  over')
    
    
    if __name__ == '__main__':
        p1 = Process(target=task1)
        p2 = Process(target=task2)
    
        p1.start()
        p2.start()
    
        
    sub1  over
    sub2  over
    sub1 run
    sub2 run
    sub1  over
    sub2  over

# 互斥锁(进程同步) #

什么是互斥锁?

互相排斥的锁

原理:

就是将要操作公共资源的代码锁起来 以保证同一时间只能有一个进程在执行这部分代码

进程之间数据不共享,但是共享同一套文件系统,同时访问同一个文件,或者打印同一个终端,那么就会产生竞争,竞争带来的结果就是错乱,如何控制，就是加锁处理

为了解决上面出现因为子进程竞争而出现的进程安全问题,为了解决这个问题,我们用到了互斥锁.

from multiprocessing import Process,Lock
    
    def task1(mutex):
        mutex.acquire()
        for i in range(10000):
            print('sub1 run')
            print('sub1  over')
            
        mutex.release()
    
    def task2(mutex):
        mutex.acquire()
        for i in range(10000):
            print('sub2 run')
            print('sub2  over')
        mutex.release()
    
    
    if __name__ == '__main__':
        mutex = Lock()
        p1 = Process(target=task1,args=(mutex,))
        p2 = Process(target=task2,args=(mutex,))
    
        p1.start()
        p2.start()

## 锁的原理 ##

def task1():
        global lock
        if lock == False:
            lock = True
            open("aaa.txt","wt")
            lock = False
    
    
    def task2():
        global lock
        if lock == False:
            lock = True
            open("aaa.txt","wt")
            lock = False

从这可以看出,锁并不是把数据锁住不让用,而是让代码不执行.

## manager 管理器 ##

多个子进程同时读写一个共享文件,虽然加了锁,但有时也会造成文件错乱问题,因为子进程之间数据不互通,即数据不同步.那么我们就需要创建一个同步通道

from multiprocessing import Process,Manager,Lock
    import time
    
    def task(data,lock):
        lock.acquire()
        num = data[0]
        time.sleep(0.2)
        data[0] = num -1
        lock.release()
    
    
    if __name__ == '__main__':
        d = [100]
        m = Manager()  # 创建一个管理器
        sync_list = m.list(d)  # 让管理器创建一个进程同步的列表(也可以是字典等)
    
        lock = Lock() # 创建一个锁
    
        ps = []
        for i in range(10):
            p = Process(target=task,args=(sync_list,lock))
            p.start()
            ps.append(p)
    
        for p in ps:p.join()
    
        print(d)
        print(sync_list)
        
    sub over
    sub over
    sub over
    sub over
    sub over
    sub over
    sub over
    sub over
    sub over
    sub over
    [100]
    [90]

**总结**:

加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即将并发改成串行,保证了数据安全,但是牺牲了速度.

虽然可以用文件共享数据实现进程间通信,但问题是:

*  效率低:共享数据是基于文件,而文件是在硬盘上
 *  需要自己加锁处理

这种方式适合交互不频繁,数据量大的情况,

对于交互频繁,数据量小的情况不合适,因此我们用另外一种解决方案:IPC(进程间通信)--队列+管道

# 队列 #

进程间相互隔离,要实现进程间通信(IPC),multiprocess模块支持两种形式:队列和管道,这两种方式都是使用消息传递的

队列是先进先出

from multiprocessing import Queue
    
    q = Queue(2)  # 创建队列,并且同时只能存储两个元素,如果不写,默认为无限大
    q.put(1)  # 将数据存入管道
    q.put(2)
    # q.put(3,block=False,timeout=3)  # block=True表示阻塞,默认为True; timeout=3表示等待延时3s,默认为None;
                                   # 当容器中没有位置了就阻塞,等待3秒,在这个时间段有人从管道里面取走一个元素,
                                   # 那么元素3就会存入进去,否则就会抛出错误 queue.Full
    
    print(q.get())  # get 是将数据取出来 并且是先进先出
    print(q.get())
    # print(q.get(block=True,timeout=3)) # 默认是阻塞,直到有人存入元素, 跟存入一样.

转载于:https://www.cnblogs.com/raynduan/p/11286466.html