昨日内容回顾

• socket基本使用

  # 内置的模块
  import socket
  
  s = socket.socket()  # 默认是TCP协议 也可以切换为UDP协议
  s.bind((ip,port))
  s.listen(5)
  sock,addr = s.accept()
  sock.recv(1204)
  sock.send(b'hello')
  
  c = socket.socket()
  c.connect((ip,port))
  ...
  

• 通信循环

  将recv和send代码区加上while循环即可
  

• 链接循环

  将监听代码区加上while循环即可
  

• 代码健壮性校验

  1.异常捕获
  2.端口冲突
  3.系统问题
  	在客户端判断用户输入是否为空	continue
  	在服务端判断接收的消息是否为空	break
  

• TCP黏包特性

  1.双向通道中数据量较大有残余
  2.TCP会将数据量较小并且时间间隔较短的数据一次性打包发送(流式协议)
  

• 如何解决黏包问题

  报头:固定长度 内部含有诸多信息
  能够固定打包数据的模块struct模块
  
  客户端
  	1.打包固定长度的字典的报头并发送
  	2.发送字典数据
  	3.发送真实数据
  服务端
  	1.先接收固定长度的报头		4
  	2.解析报头获取字典长度		255
  	3.接收字典数据并解析数据从中获取真实数据相关的信息
  	4.接收真实数据
  

• 大文件传输

  1.如何校验文件数据的一致性
  	使用hashlib模块对文件内容做加密处理比对处理之后的随机字符串(耗时)
      切片加密比对
      	读取文件部分内容加密(比如划分十块区域)
  2.数据存储
  	for循环一行行发送并一行行存储
  """昨日课堂编写的代码务必掌握！！！"""
  

• 作业剖析

  将客户端与服务端全部使用软件开发目录规范编写
  	客户端
      	bin、conf、lib、core、log、data...
      服务端
      	bin、conf、lib、core、log、data...
  # 拔高练习
  

今日内容概要

• UDP代码编写(了解即可)
• 计算机核心理论(发展史)
• 进程理论
• 开启进程的诸多方式
• 进程join方法
• 进程间数据隔离

今日内容详细

UDP代码编写(了解即可)

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.远程时间同步
"""
# 课下看看简易qq程序

操作系统的发展史

"""学习并发编程其实就是在学习操作系统的发展史(底层逻辑)"""
1.穿孔卡片时代
	CPU的利用率极低
	1、用户独占全机，资源利用率低
	2、CPU等待手工操作，CPU的利用不充分
2.联机批处理系统
	将多个程序员的程序一次性录入磁带中 之后交由输入机输入并由CPU执行
3.脱机批处理系统
	现代计算机的雏形(远程输入 高速磁带 主机)

多道技术

# 前提:单核CPU
	多道技术
    	切换+保存状态
"""
CPU工作机制
	1.当某个程序进入IO状态的时候 操作系统会自动剥夺该程序的CPU执行权限
	2.当某个程序长时间占用CPU的时候 操作系统也会剥夺该程序的CPU执行权限
"""

并行与并发(******)
	并行:多个程序同时执行
	并发:多个程序只要看起来像同时运行即可
# 问:单核CPU能否实现并行
	肯定不能，但是可以实现并发
# 问:12306可以同一时间支持几个亿的用户买票 问是并行还是并发
	肯定是并发(高并发)		
星轨:微博能够支持八个星轨

进程理论

# 进程与程序的区别
	程序:一堆代码(死的)
	进程:正在运行的程序(活的)
    
# 单核情况下的进程调度
	进程调度算法演变
		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=''
3.p.terminate()  杀死子进程 
4.p.is_alive()  判断进程是否存活	3，4结合看不出结果，因为操作系统需要反应时间。主进程睡0.1即可看出效果
"""

作业

1.整理今日内容
2.继续练习上传下载电影
代码：
    https://www.cnblogs.com/Dominic-Ji/p/10897142.html
3.预习博客内容

标签：__,udp,name,--,print,socket,time,进程,多道
来源： https://www.cnblogs.com/chenxiao1/p/15802617.html