进程相关的内容

1. 代码创建进程

"""
创建进程的方式有哪些
    1.鼠标双击桌面一个应用图标
    2.代码创建
    
创建进程的本质:在内存中申请一块内存空间用于运行相应的程序代码
"""

　　1.2 创建进程的两种方式

　　　　第一种创建方式

from multiprocessing import Process
import time


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


if __name__ == '__main__':
    p = Process(target=task, args=('dragon',))  # 创建一个进程对象
    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('python')
    p.start()
    print('主进程')

 

 

2. 进程实现并发

服务端代码

import socket
from multiprocessing import Process

def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    return server

# 将服务客户端的代码封装成函数(通信代码)
def talk(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())

if __name__ == '__main__':
    server = get_server()
    while True:
        sock, addr = server.accept()
        p = Process(target=talk, args=(sock, ))
        p.start()

 

客户端代码

import socket


client = socket.socket()
client.connect(('127.0.0.1', 8080))

while True:
    client.send(b'python cat')
    data = client.recv(1024)
    print(data.decode('utf8'))

 

 

 

 

 

 

3. Join方法

# 让主进程代码等待子进程代码运行完毕再执行
1.join方法的简单使用
2.如何真正理解等待的过程

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=('cat', 1))
    p2 = Process(target=task, args=('dog', 2))
    p3 = Process(target=task, args=('chicken', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('主进程', f'总耗时:{end_time}')
    
"""
需求:想让p.start()之后的代码 等待子进程全部运行结束之后再打印
    1.sb(sweet baby)做法:直接sleep
        肯定不行 因为子进程运行的时间不可控
    2.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=('cat', 1))
    p2 = Process(target=task, args=('dog', 2))
    p3 = Process(target=task, args=('chicken', 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}')

 

 

原因分析:因为Python代码是自上而下运行的
第一段代码是将所有进程都启动后,然后使用join等待,所以三个进程都是在运行的
第二代码是启动一个进程,然后join等待,所以启动第一个进程的时候,第二个进程并没有启动,所以需要等待第一个进程结束才能启动,第二段代码时间就先后对应的增长

 

4. 进程间数据默认隔离

# 内存可以看成是有很多个小隔间组成的 彼此不干扰
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)
 
"""默认隔离  但是可以通过一些技术打破"""

 

 

5. 进程对象属性和方法

"""
进程号如何查看
    windows:             tasklist结果集中PID
    mac:                    ps -ef
"""
1.查看进程号的方法
  1.1.current_process函数
      from multiprocessing import Process, current_process
      current_process().pid
     # 获取进程号的用处之一就是可以通过代码的方式管理进程
      windows              taskkill关键字
    mac/linux          kill关键字
  1.2.os模块
      os.getpid()  # 获取当前进程的进程号
      os.getppid()  # 获取当前进程的父进程号
2.杀死子进程
    terminate()
3.判断子进程是否存活
    is_alive()

 

from multiprocessing import Process, current_process
import os

money = 999


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


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print(current_process().pid)
    print(os.getpid())
    print(p.is_alive())
    p.join()
    print(money)

 

 

6. 僵尸进程与孤儿进程

僵尸进程
    # 为什么主进程默认需要等待子进程结束才会结束
  所有的子进程在运行结束之后都会变成僵尸进程(死了没死透)
  还保留着pid和一些运行过程的中的记录便于主进程查看(短时间保存)
  这些信息会被主进程回收(僵尸彻底死了)
      1.主进程正常结束
    2.调用join方法
  
孤儿进程
    # 子进程存活着 父进程意外死亡
  子进程会被操作系统自动接管(儿童福利院)

 

 

 

 

7. 守护进程

from multiprocessing import Process
import time


def task(name):
    print(f'{name}正常活着')
    time.sleep(3)
    print(f'{name}饿死了')

if __name__ == '__main__':
    p = Process(target=task, args=('猫主人',))
    p.start()
    print('Cat饿死了')

 

 

"""
守护即死活全部参考守护的对象
    对象死立刻死
"""
from multiprocessing import Process
import time


def task(name):
    print(f'{name}正常活着')
    time.sleep(3)
    print(f'{name}饿死了')

if __name__ == '__main__':
    p = Process(target=task, args=('猫主人',))
    # 必须写在start前面
    p.daemon = True  # 将子进程设置为守护进程:主进程结束 子进程立刻结束
    p.start()
    print('Cat饿死了')

 

 

8. 互斥锁

import json
from multiprocessing import Process, Lock
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, mutex):
    search(name)
    # 只需要把买票环节变成串行即可
    mutex.acquire()  # 抢锁
    buy(name)
    mutex.release()  # 放锁


# 模拟多人同时抢票
if __name__ == '__main__':
    # 互斥锁在主进程中产生一把 交给多个子进程用
    mutex = Lock()
    for i in range(1, 10):
        p = Process(target=run, args=('用户:%s' % i, mutex))
        p.start()