进程

今日内容概要

  • UDP代码编写
  • 操作系统发展史
  • 多道技术
  • 进程理论
  • 创建进程
  • 进程的join方法
  • 进程间默认无法交互
  • 进程对象方法

UDP代码编写

1.服务端
import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)  # UDP协议
udp_sk.bind(('127.0.0.1',9000))  # 绑定地址
msg,addr = udp_sk.recvfrom(1024)
udp_sk.sendto(b'hi',addr)             
udp_sk.close()

2.客户端
import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

进程

操作系统发展史

1.穿空卡片时代
人为将卡片输入计算机,cpu利用率低

2.联机批处理系统
将多个程序一次性录入磁带,之后交由输入机输入并由cpu处理

3.脱机批处理系统
现代计算机雏形(远程输入,高速磁带,主机)

多道技术

前提是单核cpu
多道技术:切换+保存状态

“”“
cpu工作机制
  1.当某个程序进入IO状态的时候 操作系统会自动剥夺该程序的CPU执行权限
  2.当某个程序长时间占用CPU的时候 操作系统也会剥夺该程序的CPU执行权限
”“”

并发与并行
  并发:多个系统看起来像同时运行
  并行:多个程序同时运行

进程理论

进程与程序的区别:
      程序:一堆代码
      进程;正在运行的程序

进程调度算法演变:
  1.FCFS
  2.短作业优先调度算法
  3.时间片转轮法+多级反馈队列
     先分配给新的多个进程相同的时间片
     之后根据进程消耗的时间片多少分类别

进程三状态:就绪态,运行态,阻塞态
          程序要想进入运行态就必须先进入就绪态

同步和异步:
   同步:提交完任务之后原地等待任务的返回结果,期间不做任何事
   异步:提交完任务之后不原地等待任务的返回结果 直接去做其他事 结果由反馈机制自动提醒
    '''用于描述任务的提交方式'''

阻塞与非阻塞:
   阻塞:阻塞态
   非阻塞:就绪态 运行态
    '''用于描述任务的执行状态'''

创建进程

代码层面创建进程

"""
在windows中开设进程类似于导入模块
    从上往下再次执行代码
一定需要在__main__判断语句内执行开设进程的代码

在linux中是直接将代码完整的复制一份执行
    不需要在__main__判断语句内执行
"""

方法一
from multiprocessing import Process
import time
import os


# 函数创建进程
def test(name):
    print(os.getpid())  # 当前进程id
    print(os.getppid())  # 父进程id
    print('%s is start' % name)
    time.sleep(3)
    print('%s is end' % name)


if __name__ == '__main__':
    p = Process(target=test, args=('sss',))  # 生成一个进程对象
    p.start()  # 告诉操作系统开设一个新的进程,异步提交
    print(os.getpid())
    print('主')

方法二
# 类创建进程
class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is start' % self.name)
        time.sleep(3)
        print('%s is end' % self.name)


if __name__ == '__main__':
    p = MyProcess('swj')
    p.start()
    print('主')

进程

进程的join方法

from multiprocessing import Process
import time


def index(name, n):
    print('%s is start' % name)
    time.sleep(n)
    print('%s is end' % name)


if __name__ == '__main__':
    p_list = []
    time_start = time.time()
    # for i in range(1, 4):
    #     p = Process(target=index, args=(i,))
    #     p.start()
    #     p.join()  # 主进程等待子进程运行完成再接着往下运行 串行 9s+
    # print(time.time() - time_start)

    for i in range(1, 4):
        p = Process(target=index, args=(i, i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()  # 3s+ 根据运行时间最长的进程来计算运行时间
    print(time.time() - time_start)
    print('主')

进程

进程间默认无法交互

from multiprocessing import Process

money = 100


def index():
    global money  # 局部修改全局
    money = 666  # 修改的是子进程的money
    print('子', money)


if __name__ == '__main__':
    p = Process(target=index)
    p.start()
    p.join()
    print(money)
    print('主')

进程

进程对象方法

from multiprocessing import Process, current_process
import time

print(current_process().pid)  # 进程id


def index(name):
    print('%s is start' % name)
    time.sleep(3)
    print('%s is end' % name)


if __name__ == '__main__':
    p = Process(target=index, args=('sss',))
    p.start()
    p.terminate()  # 杀死子进程
    time.sleep(0.1)
    print(p.is_alive())  # 判断子进程是否存活
    print(p.name)  # 查看进程名称
    print('主')

进程

进程

上一篇:python爬虫爬取豆瓣影评并可视化


下一篇:spring boot导入Swagger