昨日内容回顾

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.预习博客内容

巴特西

3、网络并发编程--udp代码、操作系统发展史、多道技术、进程理论

昨日内容回顾

今日内容概要

今日内容详细

UDP代码编写(了解即可)

操作系统的发展史

多道技术

进程理论

创建进程

进程的join方法

进程间默认无法交互

对象方法

作业

最新文章

热门文章