进程

代码创建进程

"""
创建进程的方式有哪些
	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__':
    print('主进程开始')
    p = Process(target=task, args=('子进程',))
    p.start()
    print('主进程结束')

# 方式二
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(self.username, '姆涅牛！')


if __name__ == '__main__':
    print('主进程开始')
    p = MyProcess('子进程')
    p.start()
    print('主进程结束')

"""
强调:不同的操作系统创建进程的要求不一样
    在windows中创建进程是以导入模块的方式进行 所以创建进程的代码必须写在__main__子代码中
    否则会直接报错 因为在无限制创建进程
    在linux和mac中创建进程是直接拷贝一份源代码然后执行 不需要写在__main__子代码中
"""

进程实现并发

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

# 服务端
from multiprocessing import Process
import socket

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


def communication(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=communication, args=(sock,))
        p.start()

# 客户端
import socket

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

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

join方法

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

import time
from multiprocessing import Process


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

if __name__ == '__main__':
    print('主进程开始')
    p1 = Process(target=task, args=('a', 1))
    p2 = Process(target=task, args=('b', 2))
    p3 = Process(target=task, args=('c', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    time_spent = time.time() - start_time
    print(f'主进程结束 总耗时：{time_spent}')

此时 p1,p2,p3是异步的相当于同时都在处理

总耗时应该是最久的p3

主进程开始
a is running
c is running
b is running
a is over
b is over
c is over
主进程结束 总耗时：3.240567922592163


import time
from multiprocessing import Process


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

if __name__ == '__main__':
    print('主进程开始')
    p1 = Process(target=task, args=('a', 1))
    p2 = Process(target=task, args=('b', 2))
    p3 = Process(target=task, args=('c', 3))
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    time_spent = time.time() - start_time
    print(f'主进程结束 总耗时：{time_spent}')

此时 p1,p2,p3是同步的需p1结束然后p2结束再p3

总耗时应该三个任务总和

主进程开始
a is running
a is over
b is running
b is over
c is running
c is over
主进程结束 总耗时：6.412482023239136

进程间数据默认隔离

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

hhh = 666


def task():
    global hhh  # 局部修改全局不可变类型
    hhh = 233
    print(hhh)


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print(hhh)
    
"""默认隔离  但是可以通过一些技术打破"""

进程对象属性和方法

"""
进程号如何查看
	windows: 			tasklist结果集中PID
	mac:					ps -ef
"""

查看进程号的方法

# 1.1.current_process函数
from multiprocessing import Process, current_process

print(current_process().pid)    # 10800 随机分配

# 1.2.os模块
# os.getpid()   获取当前进程的进程号
# os.getppid()   获取当前进程的父进程号
from multiprocessing import Process
import time
import os

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


if __name__ == '__main__':
    p = Process(target=task, args=('子进程',))
    p.start()
    p.join()
    print(os.getpid())
    print(os.getppid())
    print('主进程')

'''获取进程号的用处之一 可以通过代码的方式管理进程'''
windows  		taskkill关键字
	# cmd 结束进程  taskkill /pid 进程号 -f
mac/linux  		kill关键字

杀死子进程

# terminate()
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__':
    print('主进程开始')
    p = Process(target=task, args=('子进程',))
    p.start()
    p.terminate()
    print('主进程结束')

# 输出
主进程开始
主进程结束

判断子进程是否存活

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__':
    print('主进程开始')
    p = Process(target=task, args=('子进程',))
    p.start()       # 子进程开始运行
    print(p.is_alive())     # 判断子进程是否存活 True
    p.terminate()       # 杀死子进程 告诉操作系统杀死子进程 需要一点时间(销毁数据 回收空间)
    time.sleep(0.1)
    print(p.is_alive())     # 判断子进程是否存活 False
    print('主进程结束')

僵尸进程与孤儿进程

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

守护进程

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

from multiprocessing import Process
import time


def task(name):
    print(f'{name} 入朝为官')
    time.sleep(10)
    print(f'{name} 加官进爵')
    time.sleep(10)
    print(f'{name} 一人之下')


if __name__ == '__main__':
    p = Process(target=task, args=('刘大人',))
    # 必须写在start前面
    p.daemon = True  # 将子进程设置为守护进程:主进程结束 子进程立刻结束
    p.start()
    time.sleep(1)
    print('大清亡了')

'''
	子进程刘大人入朝为官 
	可刘大人拥戴守护的主进程大清亡了 直接断了刘大人的仕途 
	子进程也随主进程立刻结束	刘大人的仕途也随大清亡了
'''

互斥锁

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

上午10:00打开买票软件查看票数 系统给你发过来的是10:00对应的数据
只要你页面不刷新不点击下一步 那么页面数据永远展示的是10:00的
"""

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()

当多个进程操作同一份数据的时候会造成数据的错乱！！！
这个时候需要加锁处理(互斥锁)
	将并发变成串行 牺牲了效率但是保证的数据的安全
 
互斥锁并不能轻易使用 容易造成死锁现象
互斥锁只在处理数据的部分加锁 不能什么地方都加 严重影响程序的效率


查票可以一次性给所有人看 但是买票环节必须'排队'>>>:互斥锁

from multiprocessing import Process, Lock
mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 放锁
ps:我们以后在编程生涯中几乎不会自己操作锁 理解原理即可
  
"""
锁相关知识
	行锁:针对行数据加锁 同一时间只能一个人操作
	表锁:针对表数据加锁 同一时间只能一个人操作
锁的应用范围很广 但是核心都是为了保证数据的安全!!!
"""

posted @ 2022-04-19 23:36 扶我上码阅读(159) 评论(0) 编辑收藏举报

刷新页面返回顶部

（评论功能已被禁用）

相关博文：

· 锁、进程池、线程池、协程

· UDP、操作系统发展史、进程

· Python进程内容

· 进程、互斥锁

· 进程相关的内容

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

扶我上码

进程

代码创建进程

进程实现并发

join方法

进程间数据默认隔离

进程对象属性和方法

查看进程号的方法

杀死子进程

判断子进程是否存活

僵尸进程与孤儿进程

守护进程

互斥锁

公告

常用链接

最新随笔

积分与排名

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论