标签：__ name 周结 print 报头 服务端 客户端

本周总结

软件开发架构

规定了程序的请求逻辑、功能分块

1.C/S架构
	Client:客户端    
	Server:服务端
		"""
		我们使用计算机下载下来的一个个app本质是各大互联网公司的客户端软件
		通过这些客户端软件我们就可以体验到各个互联网公司给我们提供的服务
			eg:
				下载淘宝客户端 打开 体验淘宝服务端提供的购物服务
				下载抖音客户端 打开 体验抖音服务端提供的视频服务 
		ps:一般情况下客户端与服务端交互需要互联网 但是有些不需要(因为客户端和服务端都在一台计算机上)
		
		客户端:即将要去消费的客人
		服务端:给客人提供服务的店
		
		作为服务端必备的多个条件
			1.24小时不间断提供服务
			2.固定的地址
			3.能够服务多个客人(高并发)
		"""
2.B/S架构
	Browser:浏览器
	Server:服务器/端
		"""
		浏览器可以充当所有服务端的客户端
		
		ps:B/S架构本质还是C/S架构
		"""
 
'''
C/S架构
	优势:不同公司的客户端由不同公司独立开发 可以高度定制化客户端功能
	劣势:需要下载才能使用
B/S架构
	优势:不用下载直接访问
	劣势:无法高度定制化 并且需要遵守很多规则
'''

OSI七层协议

"""
OSI七层协议:规定了所有的计算机在远程数据交互的时候必须经过相同的处理流程、在制造过程中必须拥有相同的功能硬件
"""
应用层
表示层
会话层
传输层
网络层
数据链路层
物理连接层
ps:应、表、会、传、网、数、物

'''常见的是整合之后五层或者四层'''
应用层
传输层
网络层
数据链路层
物理连接层

应用层
传输层
网络层
网络接口层

"""
接收网络消息 数据由下往上传递
发送网络消息 数据由上往下传递
"""

网络相关专业名词

计算机之间要想实现数据交互必须要'连接'到一起

1.交换机
	能够讲所有接入交换机的计算机彼此互联起来
2.广播
	首次查找接入同一个交换机的其他计算机 需要朝交换机里面吼一嗓子
3.单播
	首次被查找的计算机回应查找它的计算机 并附带自己的mac地址
4.广播风暴
	接入同一台交换机的多台计算机同时发广播
5.局域网
	可以简单的理解为有单个交换机组成的网络
	在局域网内可以直接使用mac地址通信
6.广域网
	介意简单的理解为范围更大的局域网
7.互联网
	由所有的局域网、广域网连接到一起形成的网络
8.路由器
	不同的局域网计算机之间是无法直接实现数据交互的 需要路由器连接

传输层TCP与UDP协议

TCP与UDP都是用来规定通信方式的
	通信的时候可以随心所欲的料 也可以遵循一些协议符合要求的聊
    随心所欲的聊:文字 图片 视频 小油腻话 你侬我侬
	遵循一些协议:开头带尊称 首行空两格 只准用官话 不能打情骂俏
ps:不遵循上述协议也可以通信 只不过遵循了更合规合法合理


1.TCP协议(重要)
	三次握手建链接
    1.TCP协议也成为可靠协议(数据不容易丢失)
    	造成数据不容易丢失的原因不是因为有双向通道 而是因为有反馈机制
		给对象发消息之后会保留一个副本 知道对方回应消息收到了才会删除
    	否则会在一定时间内反复发送
	2.洪水攻击
    	同一时间内有大量的客户端请求链接 会导致服务端一直处于SYN_RCVD状态
	3.服务端如何区分客户端建立链接请求
    	可以对请求做唯一标识
	四次挥手断链接
	1.四次不能合并为三次
		因为中间需要确认消息是否发完(TIME_WAIT)
    """
	三次握手和四次挥手也可以看成是小情侣谈恋爱的过程	
			三次握手:表白在一起
			四次挥手:决裂要分手
	"""    
	ps:课下可以深入研究一下TCP图片上每个状态的具体情况

2.UDP协议
	也称之为数据报协议、不可靠协议	
  早期的QQ使用的是纯生的(没有加任何额外功能)UDP协议
  现在的QQ自己添加了很多技术和功能
 	使用UDP的原因就是因为很简单 快捷 粗暴 只要指定对方的地址就可以发消息了
  """
  TCP我们可以看成是打电话:双方你侬我侬
  UDP我们可以看成是发短信:只要发了就行 不管对方看不看
  """

socket模块

如果我们需要编写基于网络进行数据交互的程序 意味着我们需要自己通过代码来控制我们之前所学习的OSI七层(很繁琐 很复杂 类似于我们自己编写操作系统)
socket类似于操作系统 封装了丑陋复杂的接口提供简单快捷的接口

socket也叫套接字
	基于文件类型的套接字家族(单机)
    AF_UNIX
	基于网络类型的套接字家族(联网)
	AF_INET

socket代码简介

import socket


"""
以后要养成查看源码编写代码的思路
"""
# 1.产生一个socket对象并指定采用的通信版本和协议(TCP)
server = socket.socket()  # 括号内不写参数 默认就是TCP协议  family=AF_INET基于网络的套接字 type=SOCK_STREAM流式协议即TCP
# 2.绑定一个固定的地址(服务端必备的条件)
server.bind(('127.0.0.1', 8080))  # 127.0.0.1为本地回环地址 只有自己的电脑可以访问
# 3.设立半连接池(暂且忽略)
server.listen(5)
# 4.等待接客
sock, addr = server.accept()  # return sock, addr  三次握手
print(sock, addr)  # sock就是双向通道 addr就是客户端地址
# 5.服务客人
data = sock.recv(1024)  # 接收客户端发送过来的消息 1024字节
print(data.decode('utf8'))
sock.send('尊敬的客人 您说什么就是什么 一切按照您的要求来'.encode('utf8'))  # 给客户端发送消息 注意消息必须是bytes类型
# 6.关闭双向通道
sock.close()  # 四次挥手
# 7.关闭服务端
server.close()  # 店倒闭了




import socket


# 1.生成socket对象指定类型和协议
client = socket.socket()
# 2.通过服务端的地址链接服务端
client.connect(('127.0.0.1', 8080))
# 3.直接给服务端发送消息
client.send('大爷有钱 把你们店最好的给我叫出来'.encode('utf8'))
# 4.接收服务端发送过来的消息
data = client.recv(1024)
print(data.decode('utf8'))
# 5.断开与服务端的链接
client.close()

半连接池的概念

server.listen(5)  # 半连接池

当有多个客户端来链接的情况下 我们可以设置等待数量(不考虑并发问题)
假设服务端只有一个人的情况下

在测试半连接池的时候 可以不用input获取消息 直接把消息写死即可 

黏包现象

1.服务端连续执行三次recv
2.客户端连续执行三次send
问题:服务端一次性接收到了客户端三次的消息 该现象称为"黏包现象"
  
黏包现象产生的原因
	1.不知道每次的数据到底多大
	2.TCP也称为流式协议:数据像水流一样绵绵不绝没有间隔(TCP会针对数据量较小且发送间隔较短的多条数据一次性合并打包发送)
 
避免黏包现象的核心思路\关键点
		如何明确即将接收的数据具体有多大
	
ps:如何将长度变化的数据全部制作成固定长度的数据

struct模块

import struct

# info = b'hello big baby'
# print(len(info))  # 数据真实的长度(bytes)  14
# res = struct.pack('i', len(info))  # 将数据打包成固定的长度 i是固定的打包模式
# print(len(res))  # 打包之后长度为(bytes)   4           报头

# real_len = struct.unpack('i', res)
# print(real_len)  # (14,)             根据固定长度的报头 解析出真实数据的长度


# desc = b'hello my baby I will take you to play big ball'
# print(len(desc))  # 数据真实的长度(bytes)  46
# res1 = struct.pack('i', len(desc))
# print(len(res1))  # 打包之后长度为(bytes)  4           报头

# real_len1 = struct.unpack('i', res1)
# print(real_len1)  # (46,)              根据固定长度的报头 解析出真实数据的长度


"""
解决黏包问题初次版本
    客户端
        1.将真实数据转成bytes类型并计算长度
        2.利用struct模块将真实长度制作一个固定长度的报头
        3.将固定长度的报头先发送给服务端 服务端只需要在recv括号内填写固定长度的报头数字即可
        4.然后再发送真实数据
    
    服务端
        1.服务端先接收固定长度的报头
        2.利用struct模块反向解析出真实数据长度
        3.recv接收真实数据长度即可
"""

'''问题1:struct模块无法打包数据量较大的数据 就算换更大的模式也不行'''
# res = struct.pack('i', 12313213123)
# print(res)
'''问题2:报头能否传递更多的信息  比如电影大小 电影名称 电影评价 电影简介'''

'''终极解决方案:字典作为报头打包 效果更好 数字更小'''
# data_dict = {
#     'file_name': 'xxx老师教学.avi',
#     'file_size': 123132131232342342423423423423432423432,
#     'file_info': '内容很精彩 千万不要错过',
#     'file_desc': '一代神作 私人珍藏'
# }
# import json
# data_json = json.dumps(data_dict)
# print(len(data_json.encode('utf8')))  # 真实字典的长度  228
# res = struct.pack('i', len(data_json.encode('utf8')))
# print(len(res))

"""
黏包问题终极方案
    客户端 
        1.制作真实数据的信息字典(数据长度、数据简介、数据名称)
        2.利用struct模块制作字典的报头
        3.发送固定长度的报头(解析出来是字典的长度)
        4.发送字典数据
        5.发送真实数据     
    服务端
        1.接收固定长度的字典报头
        2.解析出字典的长度并接收
        3.通过字典获取到真实数据的各项信息
        4.接收真实数据长度
"""

并发编程理论

理论非常多 实战很少 但是一定要好好听
研究网络编程其实就是在研究计算机的底层原理及发展史

"""
计算机中真正干活的是CPU 
"""
操作系统发展史
	1.穿孔卡片阶段
  	计算机很庞大 使用很麻烦 一次只能给一个人使用 期间很多时候计算机都不工作
    	好处:程序员独占计算机 为所欲为
  		坏处:计算机利用率太低 浪费资源
  2.联机批处理系统
  	提前使用磁带一次性录入多个程序员编写的程序 然后交给计算机执行
    	CPU工作效率有所提升 不用反复等待程序录入
	3.脱机批处理系统
  	极大地提升了CPU的利用率
	总结:CPU提升利用率的过程

进程的并行与并发

并行
	多个进程同时执行 必须要有多个CPU参与 单个CPU无法实现并行
并发
	多个进程看上去像同时执行 单个CPU可以实现 多个CPU肯定也可以
 
判断下列两句话孰对孰错
	我写的程序很牛逼，运行起来之后可以实现14个亿的并行量
  	并行量必须要有对等的CPU才可以实现
  我写的程序很牛逼，运行起来之后可以实现14个亿的并发量
  	合情合理 完全可以实现	以后我们的项目一般都会追求高并发
ps:目前国内可以说是最牛逼的>>>:12306

进程的三状态

就绪态
	所有的进程在被CPU执行之前都必须先进入就绪态等待
运行态
	CPU正在执行
阻塞态
	进程运行过程中出现了IO操作 阻塞态无法直接进入运行态 需要先进入就绪态

同步与异步

用来表达任务的提交方式

同步
	提交完任务之后原地等待任务的返回结果 期间不做任何事
异步
	提交完任务之后不原地等待任务的返回结果 直接去做其他事 有结果自动通知

阻塞与非阻塞与异步

用来表达任务的执行状态

阻塞
	阻塞态
非阻塞    
	就绪态、运行态

创建进程的多种方式

"""
1.鼠标双击软件图标
2.python代码创建进程
"""
# from multiprocessing import Process
# import time
#
#
# def task(name):
#     print('task is running',name)
#     time.sleep(3)
#     print('task is over',name)


"""
在不同的操作系统中创建进程底层原理不一样
    windows
        以导入模块的形式创建进程
    linux/mac
        以拷贝代码的形式创建进程
"""
# if __name__ == '__main__':
#     # p1 = Process(target=task, args=('jason',))  # 位置参数
#     p1 = Process(target=task, kwargs={'name':'jason123'})  # 关键字参数
#     p1.start()  # 异步 告诉操作系统创建一个新的进程 并在该进程中执行task函数
#     # task()  # 同步
#     print('主')


from multiprocessing import Process
import time


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

    def run(self):
        print('run is running', self.name, self.age)
        time.sleep(3)
        print('run is over', self.name, self.age)


if __name__ == '__main__':
    obj = MyProcess('jason', 123)
    obj.start()
    print('主')

进程间数据隔离

同一台计算机上的多个进程数据是严格意义上的物理隔离(默认情况下)

from multiprocessing import Process
import time

money = 1000


def task():
    global money
    money = 666
    print('子进程的task函数查看money', money)


if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()  # 创建子进程
    time.sleep(3)  # 主进程代码等待3秒
    print(money)  # 主进程代码打印money

进程的join方法

from multiprocessing import Process
import time


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


if __name__ == '__main__':
    p1 = Process(target=task, args=('jason1', 1))
    p2 = Process(target=task, args=('jason2', 2))
    p3 = Process(target=task, args=('jason3', 3))
    # p.start()  # 异步
    '''主进程代码等待子进程代码运行结束再执行'''
    # p.join()
    # print('主')
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    # p1.join()
    # p2.join()
    # p3.join()
    print(time.time() - start_time)  # 3秒多

标签：__,name,周结,print,报头,服务端,客户端
From： https://www.cnblogs.com/DragonY/p/16909048.html