python学习-Day35

目录

• 今日内容详细
  • 代码创建进程
    • 创建进程的方式
      • 第一种创建进程的方式
      • 创建进程的第二种方式
    • 进程实现并发
    • join方法
    • 进程间数据默认隔离
    • 进程对象属性和方法
      • 进程号如何查看
      • 查看进程号的方法
      • 杀死子进程
      • 判断子进程是否存活
    • 僵尸进程与孤儿进程
      • 僵尸进程
      • 孤儿进程
    • 守护进程
    • 互斥锁(重要)
      • 概念
      • 互斥锁的使用
        • 例子：
      • 锁相关知识

今日内容详细

代码创建进程

创建进程的方式

1.鼠标双击桌面一个应用图标

2.代码创建

创建进程的本质:在内存中申请一块内存空间用于运行相应的程序代码

第一种创建进程的方式

from multiprocessing import Process
import time

def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)

if __name__ == '__main__':
    p = Process(target=task, args=('jason',))  # 创建一个进程对象
    p.start()  # 告诉操作系统创建一个新的进程
    print('主进程')

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

    在windows中创建进程是以导入模块的方式进行，所以创建进程的代码必须写在__main__子代码中
    否则会直接报错 因为在无限制创建进程

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

创建进程的第二种方式

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self, username):
        self.username = username
        super().__init__()

    def run(self):
        print('你好啊 小姐姐', self.username)
        time.sleep(3)
        print('get out!!!', self.username)

if __name__ == '__main__':
    p = MyProcess('tony')
    p.start()
    print('主进程')

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

进程实现并发

"""
将与客户端通信的代码封装成一个函数
之后每来一个客户端就创建一个进程专门做交互
"""

join方法

让主进程代码等待子进程代码运行完毕再执行

'''一般而言，主程序中如果单为一句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, n):
    print(f'{name} is running')
    time.sleep(n)
    print(f'{name} is over')

if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))  # 创建一个进程对象
    p2 = Process(target=task, args=('tony', 2))  # 创建一个进程对象
    p3 = Process(target=task, args=('kevin', 3))  # 创建一个进程对象
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()

    # join只针对主进程，如果join下面多次join他是不阻塞的
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('主进程', f'总耗时:{end_time}')  # 主进程 总耗时:3.015652894973755

# tony is running
# kevin is running
# jason is running
# jason is over
# tony is over
# kevin is over
# 主进程 总耗时:3.359032154083252

# 如果是一个start一个join交替执行 那么总耗时就是各个任务耗时总和
from multiprocessing import Process
import time

def task(name, n):
    print(f'{name} is running')
    time.sleep(n)
    print(f'{name} is over')

if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))  # 创建一个进程对象
    p2 = Process(target=task, args=('tony', 2))  # 创建一个进程对象
    p3 = Process(target=task, args=('kevin', 3))  # 创建一个进程对象
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    end_time = time.time() - start_time
    print('主进程', f'总耗时:{end_time}')  # 主进程 总耗时:7.027915000915527

# jason is running
# jason is over
# tony is running
# tony is over
# kevin is running
# kevin is over
# 主进程 总耗时:7.027915000915527

"""
需求:想让p.start()之后的代码 等待子进程全部运行结束之后再打印
    1.sb(sweet baby)做法:直接sleep
        肯定不行 因为子进程运行的时间不可控
    2.join方法
        针对多个子进程的等待一定要理解
"""

进程间数据默认隔离

# 内存可以看成是有很多个小隔间组成的 彼此不干扰
from multiprocessing import Process

money = 999

def task():
    global money  # 局部修改全局不可变类型
    money = 666

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()  # 确保子进程代码运行结束再打印money
    print(money)

# 999
# 666
"""默认隔离，但是可以通过一些技术打破"""

进程对象属性和方法

进程号如何查看

windows:				tasklist结果集中PID
	mac:				ps -ef

查看进程号的方法

# 1.current_process函数
  	from multiprocessing import Process,current_process
    a=999
    def test():
        global a
        a=666
        print(a) # 666
    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) # 999

 	# 获取进程号的用处之一就是可以通过代码的方式管理进程
  	windows				taskkill关键字
    mac/linux			kill关键字

# 2.os模块
import os
    from multiprocessing import Process,current_process
    a=999
    def test():
        global a
        a=666
        print(a) # 666
    if __name__ == '__main__':
        p = Process(target=test)
        p.start()
        print(os.getpid()) # 9748 获取当前进程的进程号
        print(os.getppid()) # 5220 获取当前进程的父进程号
        print(a) # 999

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

杀死子进程

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

from multiprocessing import Process, current_process
import time

a = 999

def test():
    global a
    time.sleep(3)
    a = 666
    print(a)

if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    p.terminate()
    print(a)

# 999

判断子进程是否存活

# 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和一些运行过程的中的记录便于主进程查看(短时间保存)
  这些信息会被主进程回收(僵尸彻底死了)
  	1.主进程正常结束
    2.调用join方法

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

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

孤儿进程

# 孤儿进程(无害)：
	一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

# 子进程存活着 父进程意外死亡
# 子进程会被操作系统自动接管(儿童福利院)

守护进程

正常情况下,主进程默认等待子进程调用结束之后结束；守护进程在主进程执行代码结束后,自动终止

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

# 主进程代码运行完毕,守护进程就会结束
from multiprocessing import Process
import time
import os

def task():
    print("进程%s开启" % os.getpid())
    time.sleep(5)
    print("进程%s结束" % os.getpid())

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

    # 必须写在start前面
    p.daemon = True  # 将子进程设置为守护进程:主进程结束，子进程立刻结束（这一行代码会把子进程变成守护代码，主进程运行完，子进程也就运行完了，不会打印进程结束的那行代码）
    p.start()
    print("主：%s" % os.getpid())
    time.sleep(3)

# 主：1992
# 进程16908开启

互斥锁(重要)

概念

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

# 注意:
	互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

	互斥锁的意思就是互相排斥，我们可以把多个进程比喻多个人，互斥锁的工作原理就是多个人去争抢共同的一个资源：如多个人要上同一个卫生间，一个人抢到卫生间后上一把锁，其他人都有外面等着，等到这个人
完成后解锁后，其他人又可以去争夺。所以互斥锁的原题，就是把某一功能并发改串行，虽然降低了效率，但保证了数据安全不错乱。

互斥锁的使用

 from multiprocessing import Process,Lock
    # 创建锁
    mutex = Lock()

    # 上锁
    mutex.acquire()

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

    # 释放锁
    mutex.release()

# 注意点:
	acquire和release方法之间的代码同一时刻只能有一个线程去操作
	如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。

例子：

"""
每逢节假日抢票
	手机上明明显示还有余票 但是点击购买的时候却提示已经没有票了
	之后回到查询页面发现确实显示没有票了

上午10:00打开买票软件查看票数 系统给你发过来的是10:00对应的数据
只要你页面不刷新不点击下一步 那么页面数据永远展示的是10:00的
"""
# 代码模拟抢票(有问题)
import json
from multiprocessing import Process
import time
import random

# 查票
def search(name):
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print(f'{name}查询当前余票:%s' % data.get('ticket_num'))

# 买票
def buy(name):
    '''
    点击买票是需要再次查票的 因为期间其他人可能已经把票买走了
    '''
    # 1.查票
    with open(r'ticket_data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    time.sleep(random.randint(1, 3))
    # 2.判断是否还有余票
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'ticket_data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print(f'{name}抢票成功')
    else:
        print(f'{name}抢票失败 没有余票了')

def run(name):
    search(name)
    buy(name)

# 模拟多人同时抢票
if __name__ == '__main__':
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i,))
        p.start()

############################################################
当多个进程操作同一份数据的时候会造成数据的错乱
这个时候需要加锁处理(互斥锁)：
	将并发变成串行 牺牲了效率但是保证的数据的安全

互斥锁并不能轻易使用，容易造成死锁现象
互斥锁只在处理数据的部分加锁，不能什么地方都加，严重影响程序的效率
############################################################
查票可以一次性给所有人看，但是买票环节必须'排队'>>>:互斥锁

锁相关知识

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

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