今日内容概要

• 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('主')