032_进程2

守护进程

　　1）正常的子进程没有执行完的时候主进程要一直等着

　　2）守护进程的进程的作用：
　　　守护进程会随着主进程的代码执行结束（此时主进程不一定结束）而结束。
　　3）守护进程是否结束的判断标准是：
　　　主进程的代码是否执行完。不是主进程是否结束。
　　4）主进程的代码执行完后会要等着所有子进程结束之后结束。
　　5）守护进程不会等待其它子进程结束，和子进程无关。但如果想让守护进程等待某个子程序结束后再结束，可以在主程序后使用p.join()设置阻塞，即主程序会等待该子进程，而等待这个代码是主进程的代码，即主进程代码没有执行完，所以守护进程不会结束。
　　6）守护进程要在start之前设置
　　7）守护进程中不能再开启子进程

1，开一个守护进程

　　1）父进程做自己的事，开一个报时器子进程，每过一秒通报一次。但是父进程的代码执行完后子进程并不会结束。
　　2）设置守护进程后，父进程的代码执行完后，子进程也会结束。

import time
from multiprocessing import Process

def cal_time():        # 定义一个报时器
    while True:
        time.sleep(1)
        print('过去了1秒')

if __name__ == '__main__':
    p = Process(target=cal_time)
# 一定在开启进程之前设置 # 将接下来开启的一个进程设置成守护进程
#    p.daemon = True     
    p.start()
    for i in range(100):    # 10s
        time.sleep(0.1)
        print('*'*i)

2，使守护进程等待一个子进程结束之后在结束

import time
from multiprocessing import Process
def func():
    print('--'*10)
    time.sleep(15)
    print('--'*10)

def cal_time():
    while True:
        time.sleep(1)
        print('过去了1秒')

if __name__ == '__main__':
    p = Process(target=cal_time)
    p.daemon = True     # 一定在开启进程之前设置
    p.start()
    p2 = Process(target=func)  # 15s
    p2.start()
    for i in range(100):    # 10s
        time.sleep(0.1)
        print('*'*i)
    p2.join()       # 使守护进程等待一个子进程结束之后在结束
# 此处阻塞，子进程p2不结束主程序代码就不会执行完

process 中的部分方法

3，process 中的方法　　p.is_alive()　　p.terminate()

　　# p.is_alive() # 是否活着 True代表进程还在 False代表进程不在了
　　# p.terminate() # 结束一个进程,但是这个进程不会立刻被杀；强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁

import time
from multiprocessing import Process
def func():
    print('wahaha')
    time.sleep(5)
    print('qqxing')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.is_alive())     # True
    time.sleep(0.1)
    p.terminate()           # 给操作系统发出结束进程的请求，# 是个异步操作，同步的会等在这。
    print(p.is_alive())     # True   #不会立即结束进程，会有一点延迟。
    time.sleep(1)
    print(p.is_alive())     # False  # 进程结束。
# 结果：
# True
# wahaha
# True
# False

process 中的部分属性

4，process 中的属性

　　# pid 查看这个进程进程id
　　# name 查看这个进程的名字

def func():
    print('wahaha')
    time.sleep(5)
    print('qqxing')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.name,p.pid) 
    p.name = '哇哈哈哈'    # 改进程的名字
    print(p.name)

5，如何能在子进程里查看该子进程的name，pid。

class MyProcess(Process):
    def run(self):
        print('wahaha',self.name,self.pid)
        time.sleep(5)
        print('qqxing',self.name,self.pid)
if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print(p.pid)

锁

1）为什么需要锁？
因为实现了异步进程，各进程互不干扰，当多个进程同时访问同一个文件时会出现问题。例如，文件中记录有10张票，（多个人）多个进程同时访问，拿到的记录是一样的，每个进程拿到的都是10，每个进程都执行的是10-1，然后有都写入文件，文件记录为9张票。事实上，我们知道，不止卖了一张票。为防止此状况的出现，使用了锁的方式。

2）什么是锁？
一个文件设置一个锁，当一个进程访问文件时，其它进程就不能进入，当这个进程进行完该文件的操作。其它进程才能访问。
相当于，一个上锁的房间，门外挂着一把钥匙，要访问的进程都去强这把钥匙，抢到的进程拿着钥匙进入房间并锁上房间，处理完出来后在把钥匙还挂在门外，其它进程在抢。

3）锁就是在并发编程中保证数据安全

7，创建锁

猜你喜欢