创建进程

    在python中提供了一个multiprocessing模块可以帮助我们使用多进程解决问题。在multiprocessing

模块中有一个类Process。

    from multiprocessing import Process

'''

    group=None, 为日后开发新功能准备

    target=None, 目标任务

    name=None, 进程的姓名

    args=(), 目标任务需要的位置参数

    kwargs={}, 目标任务需要的字典参数

    daemon=None):默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置

    '''

    #方法介绍

    p.start()#开启进程，使用run()方法

    p.run()#进程启动时运行的方法是它去调用target指定的目标

    p.terminate()#强制终止进程，不会进行清理操作

    p.is_alive()#判断进程是否存活

    p.join([timeout])#让在join方法之后的进程等待，直到p进程运行结束

"""

强调:不同的操作系统创建进程的要求不一样

    在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中

    否则会直接报错 因为在无限制创建进程

    在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中

"""

第一种方法

    from multiprocessing import Process

    import time

    def test():

        print('=======>')

        time.sleep(3)

        print('=======>')

    def test1(name):

        print(f'{name}')

        time.sleep(3)

        print('=======>')

    if __name__ == '__main__':

        p = Process(target=test)

        # p = Process(target=test1, args=('春游去动物园',))

        p.start()

        print('主')

第二种方法

    from multiprocessing import Process

    class Test(Process):

        def __init__(self,name):

            super().__init__()

            self.name = name

        def run(self):

            print(self.name)

    if __name__ == '__main__':

        p = Test('test')

        p.start()

        print('主')

    #自定义类主要是改写他的run()方法，run()方法在调用start()方法时一定会被调用

join

'''join让主进程等待子进程结束之后，再执行主进程。'''

    from multiprocessing import Process

    import time

    def task(name):

        print(f"{name} is running")

        time.sleep(2)

        print(f"{name} is gone")

    if __name__ == "__main__":

        p = Process(target=task, args=("春游去动物园",))  # 创建一个进程对象

        p.start()

        # p.join()

        print(111)

        print("主开始")

    111

    主开始

    春游去动物园 is running

    春游去动物园 is gone

    from multiprocessing import Process

    import time

    def task(name):

        print(f"{name} is running")

        time.sleep(2)

        print(f"{name} is gone")

    if __name__ == "__main__":

        p = Process(target=task, args=("春游去动物园",))  # 创建一个进程对象

        p.start()

        p.join()

        print(111)

        print("主开始")

    春游去动物园 is running

    春游去动物园 is gone

    111

    主开始

'''一般而言，主程序中如果单为一句print，则优先执行print语句（如果执行语句够多，则可见子进程执行）'''

    from multiprocessing import Process

    import time

    def task(name):

        print(f"{name} is running")

        time.sleep(2)

        print(f"{name} is gone")

    if __name__ == "__main__":

        p = Process(target=task,args=("春游去动物园",))  # 创建一个进程对象

        p.start()

        # p.join()

        print(111)

        time.sleep(0.5)

        print("主开始")

    111

    春游去动物园 is running

    主开始

    春游去动物园 is gone

'''如果程序中有连续多个join函数，则只有最先的join是起作用的'''

    from multiprocessing import Process

    import time

    def task(name,sec):

        print(f"{name} is running")

        time.sleep(sec)

        print(f"{name} is gone")

    if __name__ == "__main__":

        start_time = time.time()

        p = Process(target=task,args=("常",3))  # 创建一个进程对象

        p1 = Process(target=task,args=("辛",5))  # 创建一个进程对象

        p2 = Process(target=task,args=("王",1))  # 创建一个进程对象

        p.start()

        p1.start()

        p2.start()

        # join只针对主进程，如果join下面多次join他是不阻塞的

        p.join()

        p1.join()

        p2.join()

        print(f"主{time.time()-start_time}")

    辛 is running

    常 is running

    王 is running

    王 is gone

    常 is gone

    辛 is gone

    主5.103694438934326

    # 注：如果不是连续多个，比如这样：

    from multiprocessing import Process

    import time

    def task(name,sec):

        print(f"{name} is running")

        time.sleep(sec)

        print(f"{name} is gone")

    if __name__ == "__main__":

        start_time = time.time()

        p = Process(target=task,args=("常",3))  # 创建一个进程对象

        p1 = Process(target=task,args=("辛",5))  # 创建一个进程对象

        p2 = Process(target=task,args=("王",1))  # 创建一个进程对象

        p.start()

        p.join()

        p1.start()

        p1.join()

        p2.start()

        p2.join()

        print(f"主{time.time()-start_time}")

    常 is running

    常 is gone

    辛 is running

    辛 is gone

    王 is running

    王 is gone

    主9.267089128494263

    # 这样就会先执行p进程，再执行p1进程，再执行p2进程

进程间数据默认隔离

    from multiprocessing import Process

    a=100

    def test():

        global a

        a=50

        print(a) # 50

    if __name__ == '__main__':

        p = Process(target=test)

        p.start()

        print(a) # 100

    100

    50

进程对象属性和方法

查看进程号

    '''第一种current_process函数'''

    from multiprocessing import Process,current_process

    a=100

    def test():

        global a

        a=50

        print(a) # 50

    if __name__ == '__main__':

        p = Process(target=test)

        p.start()

        print(current_process()) # 获取进程的名称 <_MainProcess name='MainProcess' parent=None started>

        print(current_process().pid) # 获取进程的id 8560

        print(a) # 100

    '''第二种os模块'''

    import os

    from multiprocessing import Process,current_process

    a=100

    def test():

        global a

        a=50

        print(a) # 50

    if __name__ == '__main__':

        p = Process(target=test)

        p.start()

        print(os.getpid()) # 9748 获取当前进程的进程号

        print(os.getppid()) # 5220 获取当前进程的父进程号

        print(a) # 100

    os.getpid()  # 获取当前进程的进程号

    os.getppid()  # 获取当前进程的父进程号

杀死子进程

    terminate()：不管任务是否完成，立即终止子进程

    from multiprocessing import Process,current_process

    import time

    a=100

    def test():

        global a

        time.sleep(3)

        a=50

        print(a)

    if __name__ == '__main__':

        p = Process(target=test)

        p.start()

        p.terminate()

        print(a)

    100

判断子进程是否存活

    is_alive()：判断进程子进程是否还在活着

    from multiprocessing import Process,current_process

    import time

    a=100

    def test():

        global a

        time.sleep(3)

        a=50

        print(a)

    if __name__ == '__main__':

        p = Process(target=test)

        p.start()

        print(p.is_alive()) # True

        p.terminate() # 杀死进程

        time.sleep(0.5)

        print(p.is_alive()) # False

僵尸进程与孤儿进程

僵尸进程

　　僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子

进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

    '''

        僵死进程：子进程退出后，会将该进程的重型资源释放掉（cpu，内存，打开的文件），子进程的进

程描述符仍然保存在系统中，比如pid。

    '''

    所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)

    程序正常结束才会产生僵尸进程，如果强制关闭父进程，操作系统会把父进程已经运行结束的子进程全部

删除，也就不会产生僵尸进程了。

    僵尸进程的危害:

      系统的pid号是有限的，僵尸进程保留的信息如果一直不被释放，一直累计会导致没有可用的pid号而

导致系统不能产生新的进程

孤儿进程

   孤儿进程(无害)：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿

进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

   '''

      子进程存活着 父进程意外死亡

      子进程会被操作系统自动接管(儿童福利院)

   '''

守护进程

    正常情况下,主进程默认等待子进程调用结束之后结束

    守护进程在主进程执行代码结束后,自动终止

    """

        守护即死活全部参考守护的对象

	对象死立刻死

    """

    主进程代码运行完毕,守护进程就会结束

    from multiprocessing import Process

    import os, time

    def task():

        print("进程%s开启" % os.getpid())

        time.sleep(10)

        print("进程%s结束" % os.getpid())

    if __name__ == '__main__':

        p = Process(target=task,daemon=True) # 在创建进程时也可以设置daemon，True为开启守护进程，默认为False。

        #p.daemon = True   	# 这一行代码会把子进程变成守护代码，主进程运行完，子进程也就运行完了，不会打印进程结束的那行代码

        p.start()

        print("主：%s" % os.getpid())

        time.sleep(3)

        主：6812

        进程10096开启

互斥锁

互斥锁的概念

    互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。

    注意:

      互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放

后，其它等待的线程再去抢这个锁。

    互斥锁的意思就是互相排斥，我们可以把多个进程比喻多个人，互斥锁的工作原理就是多个人去争抢共同

的一个资源：如多个人要上同一个卫生间，一个人抢到卫生间后上一把锁，其他人都有外面等着，等到这个人

完成后解锁后，其他人又可以去争夺。所以互斥锁的原题，就是把某一功能并发改串行，虽然降低了效率，但

保证了数据安全不错乱。

    """

    锁相关知识

    	行锁:针对行数据加锁 同一时间只能一个人操作

    	表锁:针对表数据加锁 同一时间只能一个人操作

    锁的应用范围很广 但是核心都是为了保证数据的安全!!!

    """

互斥锁的使用

    from multiprocessing import Process,Lock

    # 创建锁

    mutex = Lock()

    # 上锁

    mutex.acquire()

    ...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...

    # 释放锁

    mutex.release()

    注意点:

    acquire和release方法之间的代码同一时刻只能有一个线程去操作

    如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到

这个互斥锁释放后才能再次上锁。

互斥锁与join()的区别

    互斥锁与join()的区别：

      大前提：二者的原理都是一样，都是将并发变成串行，从而保证有序

      区别一：join是按照人为指定的顺序执行，而互斥锁是所有进程平等地竞争，谁先抢到谁先执行。

      区别二：互斥锁可以让一部分代码（修改共享数据的代码）串行，而join只能将代码整体串行。

抢票小案例

    # db.json文件中的内容为{"count": 100}

    from multiprocessing import Process, Lock

    import json, time

    import random

    def search(name):

        dic = json.load(open('db.json', 'r', encoding='utf-8'))

        time.sleep(random.randint(0, 2))  # 模拟网络延迟

        print('%s查到剩余的票数为%s张' % (name, dic['count']))

    def get(name):

        dic = json.load(open('db.json', 'r', encoding='utf-8'))

        time.sleep(0.3)  # 模拟网络延迟

        if dic['count'] > 0:

            time.sleep(0.1)  # 模拟网络延迟

            print('%s成功买到了剩下的第%s票' % (name, dic['count']))

            dic['count'] -= 1

            json.dump(dic, open('db.json', 'w', encoding='utf-8'))

    def rob_ticket(name, lock):

        search(name)

        with lock:  # 相当于获得了lock.acquire()，执行代码体完，自动执行lock.release()

            get(name)

    if __name__ == '__main__':

        lock = Lock()

        for i in range(10):

            name = '路人%s' % i

            p = Process(target=rob_ticket, args=(name, lock))

            p.start()

    执行结果：

    路人0查到剩余的票数为5张

    路人1查到剩余的票数为5张

    路人8查到剩余的票数为5张

    路人7查到剩余的票数为5张

    路人9查到剩余的票数为5张

    路人0成功买到了剩下的第5票

    路人1成功买到了剩下的第4票

    路人2查到剩余的票数为5张

    路人4查到剩余的票数为5张

    路人3查到剩余的票数为5张

    路人6查到剩余的票数为5张

    路人8成功买到了剩下的第3票

    路人7成功买到了剩下的第2票

    路人5查到剩余的票数为5张

    路人9成功买到了剩下的第1票

巴特西

创建进程，join方法，进程对象相关属性和方法，僵尸进程和孤儿进程，守护进程，互斥锁

创建进程

第一种方法

第二种方法

join

进程间数据默认隔离

进程对象属性和方法

查看进程号

杀死子进程

判断子进程是否存活

僵尸进程与孤儿进程

僵尸进程

孤儿进程

守护进程

互斥锁

互斥锁的概念

互斥锁的使用

互斥锁与join()的区别

抢票小案例

最新文章

热门文章