网络编程：进程

网络编程：进程

---

• UDP代码编写(了解即可)

• 计算机核心理论(发展史)

• 进程理论

• 开启进程的诸多方式

• 进程join方法

• 进程间数据隔离

• IPC机制

UDP代码编写

• UDP适用于对效率要求相对较高而对准确性要求相对较低的场合，例如视频在线点播、网络语音通话等等。
• socket模块中经常用于UDP编程的方法主要有：

• socket([family[,type[,proto]]])：创建一个socket对象，其中family为socket.AF_INET表示IPV4，socket.AF_INET6表示IPV6；type为SOCK_STREAM表示TCP协议，SOCK_DGRAM表示UDP协议。
• sendto(string,address)：把string指定的字节串内容发送给address指定的地址，address是一个元组，格式为(IP地址,端口号)
• recvfrom(bufsize[,flags])：接收数据

案例：

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


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.内部小电容供电，2.远程时间同步

操作系统的发展史

学习并发编程就是在学学习操作系统的发展史

1.穿孔卡片的时代

     cpu的利用率极地

2.联机批处理系统

      将多个程序员的程序一次性录入磁带中 之后交由输入机输入并由cpu执行

3.脱机批处理系统

      现代计算机的雏形（远程输入 高速磁带 主机）

多道技术

前提：单核CPU  多道技术  切换+保存状态

CPU工作机制：1.当某个程序进入io状态的时候 操作系统会自动剥夺该程序的CPU执行权限

                          2.当某个程序长时间占用CPU的时候 操作系统也会剥夺该程序的CPU执行权限

并行与并发：并行：多个程序同时执行

                      并发：多个程序只要看起来像同时运行即可

ps：单核CPU不能事项并行，但能实现并发

进程理论

进程与程序的区别：程序：一堆代码

                                 进程：正在运行的程序

单核情况下的进程调节：进程调度算法演变

                                         1.FCFS    先来先服务

                                                  对多作业不友好

                                          2.短作业优先调度算法

                                                   对长作业不友好

                                          3.时间片轮转法+多级反馈队列

                                                   先分配给新的多个进程相同的时间片

                                                    之后根据进程消耗的时间片多少分类别

进程三状态图：就绪态   运行态  阻塞态

                         进程要想进入运行态必须先经过就绪态

同步与异步：用于表述任务的提交方式

                      同步：提交完任务之后原地等待任务的返回结果 期间不做任何事

                      异步：提交完任务之后不原地等待任务的返回结果 直接去做其他事 结果有反馈机制自动提醒

阻塞与非阻塞：用于描述任务的执行状态

                         阻塞：阻塞态

                         非阻塞太：就绪态 运行态

创建进程

 代码层面创建进程

from multiprocessing import Process
import time
import os


def test(name):
    print(os.getpid())  # 获取进程号
    print(os.getppid())  # 获取父进程号
    print('%s正在运行' % name)
    time.sleep(3)
    print('%s已经结束' % name)


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

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

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

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

    def run(self):
        print('%s正在运行' % self.name)
        time.sleep(3)
        print('%s已经结束' % self.name)

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

进程的join方法

from multiprocessing import Process
import time


def test(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)


if __name__ == '__main__':
    p_list = []
    start_time = time.time()
    for i in range(1, 4):
        p = Process(target=test, args=(i, i))
        p.start()
        p_list.append(p)
        # p.join()  # 串行  9s+
    for p in p_list:
        p.join()
    print(time.time() - start_time)

    # p = Process(target=test, args=('jason',))
    # p1 = Process(target=test, args=('kevin',))
    # p2 = Process(target=test, args=('oscar',))
    # p.start()
    # p1.start()
    # p2.start()
    print('主进程')

进程间默认无法交互

进程间数据是相互隔离的

from multiprocessing import Process

money = 100


def test():
    global money
    money = 999


if __name__ == '__main__':
    p = Process(target=test)
    p.start()
    # 先确保子进程运行完毕了 再打印
    p.join()
    print(money)

对象方法

1.current_process查看进程号

2.os.getpid（）查看进程号 os。getppid（） 查看父进程进程号

3.进程的名字， p.name直接默认就有，也可以在实例化进程对象的时候通过关键字形式传入name=''

4.p.is_alive（） 判断进程是否存活 3,4结合看不出结果，是因为操作系统需要反应时间，主进程睡0.1即可看出效果

---