毛毛Python进阶之路3——进程，进程多开，守护进程，锁！

话说在写进阶2 双端交互的时候已经用到了进程多开socketserver。但那个仅仅局限在双端交互的时候，所以现在写的是啥时儿都可以。妥妥的，安排，安排……

多线程开启了在这里我整理了两个版本

使用multiprocessing 库 下的 Process 函数，具体使用方法如下！

from multiprocessing import Process
#在这里了，为了方便区分到底那位大爷先到，所以引进time库。
import time

def Ess():
    time.sleep(3)
    print("这是子线程哦！")


def Ecc():
    time.sleep(1)
    print("这也是子线程哦！嘿嘿")

if __name__ == '__main__':
    f1 = Process(target=Ess)
    f2 = Process(target=Ecc)
    f1.start()
    f2.start()
    time.sleep(2)
    print("哟！两位大爷散步了！巧了")

然后了输出结果是这样的，哎呦喂1秒的大爷最厉害了

所以了，此时我们就实现了多进程并发。三个大爷一起赛跑。

Python是一门面向对象的语言，所以了难免会出现好多“对象怪”，不用对象受不了（估计这群人是找不到对象了【手动滑稽】），2.0就是一种用类的方式来解决的并发。【注意：不是 socketserver】

from multiprocessing import Process
import time
import os

class MyProcess(Process):
    # 如果你需要传参就得用这个函数，不需要传参就不需要！
    def __init__(self, can1, can2):
        super().__init__()#一定要记得这句，钥匙没有这句话 那个时髦的小伙子会六亲不认的！
        self.can1 = can1
        self.can2 = can2

    def run(self):
        print("这是一个时髦的小伙子【有对象】",os.getpid())# os.getpid 是用来找到本进程的父进程进程号
        print("这个可以输出他爷爷的进程号",os.getppid())
        time.sleep(1)

if __name__ == '__main__':
    print("这是小伙子的爷爷",os.getpid())
    f1 = MyProcess("爸爸","妈妈")
    f1.start()
    f2 = MyProcess("爸爸1","妈妈1")
    f2.start()

    print("哟！一大家子呀！")

下面是输出结果，仔细观察进程号，你会发现点不一样的！悄悄告诉你，主进程的爸爸是pycharm，你不信看下下面！


洗不洗很神奇了，哈哈哈！

先说说啥叫守护进程。
守护进程——会随着主进程代码执行完毕而结束的进程！【注意有坑】
【坑】：不是主进程结束，是主进程代码执行完毕。比如说：有可能其他子进程没有执行完毕，程序就没有执行完毕！

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    print("哎呦喂，大爷老了，多睡了【3】秒")
def demo():
    time.sleep(1)
    print("瞧你那熊样，我就只睡了【1】秒")
if __name__ == '__main__':
    f1 = Process(target=func)
    f1.start()
    f2 = Process(target=demo)
    f2.daemon = True
    f2.start()
    time.sleep(0.5)
    #time.sleep(2)
    print(f2.is_alive())   #用来判断进程是否还活着！
    print("我是主进程！！！")

这里了可能有点不好理解
当主进程睡0.5秒的时候，f2在主进程结束前没有结束所以被强迫结束，也就没有输出。如下图

当主进程睡了2秒时，主进程还没有结束。子进程f2就已经结束了，所以输出了，子进程结束了也就False了，如下下图

为什么会有锁了？
在多进程开发的时候由于网络延迟或者其他原因出现了网络延迟可能会导致数据偏差，所以【锁】就出现了！
锁：给某一段代码加上锁，并且只配备一把钥匙，很多子线程到这里后会抢这一把钥匙，抢到的那个就能够执行下面的的代码，执行完后把钥匙还回来，另外的人又抢，这样一次只能去一个！虽然会降低效率，但数据安全得到了保障！```python
锁：

lock = lock()
lock.acquire # 拿钥匙，开门
lock.release() #还钥匙，关门

# 锁

# 火车票
import json
import time
from multiprocessing import Process
from multiprocessing import Lock

def show(i):
    with open('ticket') as f:
        dic = json.load(f)
    print('余票: %s'%dic['ticket'])

def buy_ticket(i,lock):
    lock.acquire() #拿钥匙进门
    with open('ticket') as f:
        dic = json.load(f)
        time.sleep(0.1)
    if dic['ticket'] > 0 :
        dic['ticket'] -= 1
        print('33[32m%s买到票了33[0m'%i)
    else:
        print('33[31m%s没买到票33[0m'%i)
    time.sleep(0.1)
    with open('ticket','w') as f:
        json.dump(dic,f)
    lock.release()      # 还钥匙

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=show,args=(i,))
        p.start()
    lock = Lock()
    for i in range(10):
        p = Process(target=buy_ticket, args=(i,lock))
        p.start()

输出如下

学习就是不断的记笔记，练习！总有一天，你会感谢那个努力付出的自己！

人生苦短，我学python！