标签：地址 申请 关系 请求头 http请求 pid 怎么 接受 负载均衡。
mro全称Method Resolution Order是方法解析顺序
方法调用时需要对当前类和基类进行搜索以确定方法所在的位置，搜索的顺序就是“方法解析顺序”
‘‘‘C3算法应用在python中是为了解决原来基于深度优化搜索算法不满足本地优先级和单调性的问题。
本地优先级：指声明时父类的顺序，比如C(A,B)，如果访问C类对象属性时应该根据声明顺序优先查找A类，然后再查找B类。
单调性：如果在C的解析顺序中，A排在B的前面，那么在C的所有子类里也必须满足这个顺序‘‘‘
__setattr__:添加、修改属性会触发它的执行
__delattr__:删除属性的时候会触发
__getattr__:只有在使用点调用属性且属性不存在的时候触发
__getattribute__:点调用属性不论属性是否存在，都会触发
‘‘‘
"单下划线"开始的成员变量叫做保护变量，只有类对象和子类对象自己能够访问这些变量
"双下划线"开始的是私有成员，只有类对象自己能访问，连子类对象也不能访问这个变量
‘‘‘
class Context:
pass
with Context as ctx:
ctx.do_something()
# 请在 Context 类下添加代码完成该类的实现
# 答案:
class Context(object):
def __enter__(self):
pass
def __exit__(self, exc_type, exc_val, exc_tb):
if all([exc_type, exc_val, exc_tb]):
print ‘handler except‘
print ‘exception {}‘.format(exc_val)
return True
def main():
with tornado.stack_context.StackContext(Contextor):
async_task()
‘‘‘
Python的类就是个语法糖。一个函数写在类里面和写在类外面没有区别，唯一的区别就是参数，所谓实例方法就是第一个参数是self，所谓类方法就是第一个参数是class，而静态方法不需要额外的参数，所以必须区分。
‘‘‘
基本格式
with context_expression [as target(s)]:
with-body
这里 context_expression 要返回一个上下文管理器对象，该对象并不赋值给 as 子句中的 target(s) ，如果指定了 as 子句的话，会将上下文管理器的 __enter__() 方法的返回值赋值给 target(s)。
target(s) 可以是单个变量，或者由“()”括起来的元组（不能是仅仅由“,”分隔的变量列表，必须加“()”）。
自定义的上下文管理器要实现上下文管理协议所需要的 __enter__() 和 __exit__() 两个方法
context_manager.__enter__() ：进入上下文管理器的运行时上下文，在语句体执行前调用。with 语句将该方法的返回值赋值给 as 子句中的 target，如果指定了 as 子句的话
context_manager.__exit__(exc_type, exc_value, exc_traceback) ：退出与上下文管理器相关的运行时上下文，返回一个布尔值表示是否对发生的异常进行处理。
# 答案:
1.__new__
class Borg(object):
_instance = None
def __new__(cls, *args, **kwargs):
if not hasattr(cls, ‘_instance‘):
ob = super(Borg, cls)
cls._instance = ob.__new__(cls, *args, **kwargs)
return cls._instance
class MyClass(Borg):
def __init__(self):
self.a = 1
2.共享属性
class Borg2(object):
_state = {}
def __new__(cls, *args, **kwargs):
ob = super(Borg2, cls).__new__(cls, *args, **kwargs)
ob.__dict__ = cls._state
return ob
class MyClass(Borg2):
def __init__(self):
self.a = 1
3.装饰器
def singleton(cls, *args, **kwargs):
instances = {}
def getinstance():
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return getinstance
@singleton
class MyClass(object):
def __init__(self):
self.a = 1
4.import方法
# mysingleton .py
class MyClass(object):
def __init__(self):
self.a = 1
s_myclass = MyClass()
from mysingleton import s_myclass
s_myclass.a
1、 类对象
2、 实例对象
3、 self变量名称问题
4、 类属性、实例变量、局部变量
5、 类方法
6、 实例方法
7、 类方法与实例方法相互调用
8、 静态方法
9、 继承时三类方法的影响
三次握手：
1.首先客户端向服务端发送一个带有SYN标志以及随机生成的序号100（0字节）的报文
2.服务端收到报文后返回一个报文（SYN200（0字节），ACk1001（字节+1））给客户端
3.客户端再次发送带有ACk标志201序号的报文给服务端，至此三次握手结束，客户端开始向服务端发送数据。
1客户端向服务端发起请求：我想给你通信，你准备好了么？
2服务端收到请求后回应客户端：I‘ok，你准备好了么
3客户端礼貌的再次回一下客户端：准备就绪，咱们开始通信吧！
整个过程跟打电话的过程一模一样:1喂，你在吗2在，我说的你听得到不3恩，听得到(接下来请
开始你的表演)
补充：SYN：请求询问，ACk：回复，回应。
四次挥手：
由于TCP连接是可以双向通信的（全双工）,因此每个方向都必须单独进行关闭，四次挥手过程，客户端与服务端都可以先断开连接。
1.客户端发送带有fin标识的报文给服务端，请求通信关闭
2.服务端收到信息后回复ACK答应关闭客户端通信(连接)请求，同时服务端检测自己是否有数据在向客户端发送，如果有则等待。
3.服务端发送带有fin标识的报文给客户端，也请求关闭通信
4.客户端回应ACK给服务端，答应关闭服务端的通信请求
# 答案:
# TCP和UDP的区别?
‘‘‘
1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的
UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
5、TCP首部开销20字节;UDP的首部开销小，只有8个字节
6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道
‘‘‘
# 为何基于tcp协议的通信比基于udp协议的通信更可靠？
‘‘‘
tcp:可靠 对方给了确认收到信息，才发下一个，如果没收到确认信息就重发
udp:不可靠 一直发数据，不需要对方回应
‘‘‘
# 答案:
‘‘‘
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部。
服务端:
创建socket对象，绑定ip端口bind(), 设置最大链接数listen(), accept()与客户端的connect()创建双向管道， send(), recv(),close()
客户端:
创建socket对象，connect()与服务端accept()创建双向管道, send(),recv(),close()
‘‘‘
# 答案:
‘‘‘
在互联网上防火墙是一种非常有效的网络安全模型，通过它可以隔离风险区域(即Internet或有一定风险的网络)与安全区域(局域网)的连接，同时不会妨碍人们对风险区域的访问。所以它一般连接在核心交换机与外网之间。
1.过滤进出网络的数据
2.2.管理进出访问网络的行为
3.3.封堵某些禁止业务
4.4.记录通过防火墙信息内容和活动
5.5.对网络攻击检测和告警‘‘‘
```
select、poll、epoll模型的区别?
# 答案:
‘‘‘
I/O多路复用的本质就是用select/poll/epoll，去监听多个socket对象，如果其中的socket对象有变化，只要有变化，用户进程就知道了。
select是不断轮询去监听的socket，socket个数有限制，一般为1024个；
poll还是采用轮询方式监听，只不过没有个数限制；
epoll并不是采用轮询方式去监听了，而是当socket有变化时通过回调的方式主动告知用户进程。
‘‘‘
#还可以问：Nginx为什么这么厉害？
#要从I/O多路复用来回答
‘‘‘
1.进程是操作系统资源分配的最小单位
2.线程是CPU调度的最小单位
3.同一进程中线程是资源共享的
4.协程是用户级别的，协程之间的切换由用户自行处理，节省了CPU的调度时间
‘‘‘
什么是GIL锁？
‘‘‘
全局解释器锁，每次只能一个线程获得CPU的使用权：为了线程安全，也就是为了解决多线程之间的数据完整性和状态同步而加的锁，因为我们知道线程之间的数据是共享的。
‘‘‘
请简述GIL对python性能的影响
# 答案:
‘‘‘
GIL：全局解释器锁。每个线程在执行的过程都需要先获取GIL，保证同一时刻只有一个线程可以执行字节码。
线程释放GIL锁的情况：
在IO操作等可能会引起阻塞的system call之前,可以暂时释放GIL,但在执行完毕后,必须重新获取GIL
Python 3.x使用计时器（执行时间达到阈值后，当前线程释放GIL）或Python 2.x，tickets计数达到100
Python使用多进程是可以利用多核的CPU资源的。
多线程爬取比单线程性能有提升，因为遇到IO阻塞会自动释放GIL锁
‘‘‘
# 答案:
# 线程池
import threadpool, time
with open(r‘../uoko_house_id.txt‘, ‘r‘, encoding=‘utf-8‘) as f: # with open语句表示通用的打开文件的方式，此处用来获取需要爬取参数的列表
roomIdLi = f.readlines()
roomIdList =[x.replace(‘\n‘,‘‘).replace(‘ ‘,‘‘) for x in roomIdLi]
print(roomIdList)
li = [[i, item] for i, item in enumerate(roomIdList)] # enumerate()将列表中元素和其下标重新组合输出
def run(roomId):
"""对传入参数进行处理"""
print(‘传入参数为：‘, roomId)
time.sleep(1)
def main():
roomList = li # 房间信息
start_time = time.time()
print(‘启动时间为：‘, start_time)
pool = threadpool.ThreadPool(10)
requests = threadpool.makeRequests(run, roomList)
[pool.putRequest(req) for req in requests]
pool.wait()
print("共用时:", time.time()-start_time)
if __name__ == ‘__main__‘:
main()
# 进程池
from multiprocessing.pool import Pool
from time import sleep
def fun(a):
sleep(5)
print(a)
if __name__ == ‘__main__‘:
p = Pool()
for i in range(10):
p.apply_async(fun, args= (i, ))
p.close()
p.join()
print("end")
# 答案:
python提供了多种进程通信的方式，主要Queue和Pipe这两种方式，Queue用于多个进程间实现通信，Pipe是两个进程的通信。
# Queue
from multiprocessing import Process, Queue
import os,time,random
#写数据进程执行的代码
def proc_write(q,urls):
print ‘Process is write....‘
for url in urls:
q.put(url)
print ‘put %s to queue... ‘ %url
time.sleep(random.random())
#读数据进程的代码
def proc_read(q):
print(‘Process is reading...‘)
while True:
url = q.get(True)
print(‘Get %s from queue‘ %url)
if __name__ == ‘__main__‘:
#父进程创建Queue，并传给各个子进程
q = Queue()
proc_write1 = Process(target=proc_write,args=(q,[‘url_1‘,‘url_2‘,‘url_3‘]))
proc_write2 = Process(target=proc_write,args=(q,[‘url_4‘,‘url_5‘,‘url_6‘]))
proc_reader = Process(target=proc_read,args=(q,))
#启动子进程，写入
proc_write1.start()
proc_write2.start()
proc_reader.start()
#等待proc_write1结束
proc_write1.join()
proc_write2.join()
#proc_raader进程是死循环，强制结束
proc_reader.terminate()
# PIPE
import multiprocessing
import os,time,random
#写数据进程执行的代码
def proc_send(pipe,urls):
#print ‘Process is write....‘
for url in urls:
print ‘Process is send :%s‘ %url
pipe.send(url)
time.sleep(random.random())
#读数据进程的代码
def proc_recv(pipe):
while True:
print(‘Process rev:%s‘ %pipe.recv())
time.sleep(random.random())
if __name__ == ‘__main__‘:
#父进程创建pipe，并传给各个子进程
pipe = multiprocessing.Pipe()
p1 = multiprocessing.Process(target=proc_send,args=(pipe[0],[‘url_‘+str(i) for i in range(10) ]))
p2 = multiprocessing.Process(target=proc_recv,args=(pipe[1],))
#启动子进程，写入
p1.start()
p2.start()
p1.join()
p2.terminate()
1.在写高并发服务端代码时
2.再写高性能爬虫的时候
# 答案:
‘‘‘
在互联网上，所有的地址都是ip地址，现阶段主要是IPv4（比如：110.110.110.110）。
但是这些ip地址太难记了，所以就出现了域名（比如http://baidu.com）。
域名解析就是将域名，转换为ip地址的这样一种行为。
‘‘‘
#关于域名解析详见个人博客
# 答案:
‘‘‘
生产者与消费者模式是通过一个容器来解决生产者与消费者的强耦合关系，生产者与消费者之间不直接进行通讯，
而是利用阻塞队列来进行通讯，生产者生成数据后直接丢给阻塞队列，消费者需要数据则从阻塞队列获取，
实际应用中，生产者与消费者模式则主要解决生产者与消费者的生产与消费的速率不一致的问题，达到平衡生产者与消费者的处理能力，而阻塞队列则相当于缓冲区。
应用场景：用户提交订单，订单进入引擎的阻塞队列中，由专门的线程从阻塞队列中获取数据并处理。
优势：
1；解耦
假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。
将来如果消费者的代码发生变化，可能会影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。
2：支持并发
生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有返回之前，生产者只能一直等着
而使用这个模型，生产者把制造出来的数据只需要放在缓冲区即可，不需要等待消费者来取。
3：支持忙闲不均
缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。
当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。
‘‘‘
#进度：网络编程第23题
‘‘‘
A.SNMP工作在四层
B.四层是指网络的传输层, 主要包括IP和端口信息
C.七层是指网络的应用层(协议层), 比如http协议就工作在七层
D.四层主要应用于TCP和UDP的代理, 七层主要应用于HTTP等协议的代理
‘‘‘
# 答案:
A
‘‘‘
A.屏蔽192.168.1.5访问本机dns服务端口
B.允许10.1..0/2访问本机的udp88889999端口
‘‘‘
# 答案:
‘‘‘
iptables -A INPUT -p ICMP --icmp-type 8 -m time --timestart 00:00:00 --timestop 23:59:59 --weekdays Mon -j DROP
‘‘‘
‘‘‘
要求:
1.实现server端的功能即可
2.遵循基本语言编程规范
‘‘‘
# 答案:
# 服务端:
# coding=utf-8
import socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((‘‘, 8888))
server.listen(5)
#等待客户端连接
while True:
(client, address) = server.accept()
data = client.recv(4096)
print data
client.send("hello")
client.close()
# 客户端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((‘127.0.0.1‘, 8888))
client.send("My name is client")
message = client.recv(4096)
print message
client.close()
# 答案:
‘‘‘
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
‘‘‘
所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程
‘‘‘
# 答案:
1.加锁顺序（线程按照一定的顺序加锁）
2.加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
3.死锁检测‘‘‘
# 答案:
‘‘‘
LVS ：Linux虚拟服务器
作用：LVS主要用于多服务器的负载均衡。
它工作在网络层，可以实现高性能，高可用的服务器集群技术。
它廉价，可把许多低性能的服务器组合在一起形成一个超级服务器。
它易用，配置非常简单，且有多种负载均衡的方法。
它稳定可靠，即使在集群的服务器中某台服务器无法正常工作，也不影响整体效果。另外可扩展性也非常好。
‘‘‘
在初始化Queue()对象时，(例如q=Queue()，若在括号中没有指定最大可接受的消息数量，或数
量为负值时，那么就代表可接受的消息数量没有上限-直到内存的尽头)
from multiprocessing import Process,Queue
import os,time,random
for value in [‘A‘,‘B‘,‘C‘]:
print(‘Put %s to queue...‘ % value)
q.put(value)
time.sleep(random.random()
这个问题被问的概率相当之大，其实多线程，多进程，在实际开发中用到的很少，除非是那些对项目性能要求特别高的，有的开发工作几年了，也确实没用过，你可以这么回答，给他扯扯什么是进程，线程（cpython中是伪多线程）的概念就行，实在不行你就说你之前写过下载文件时，用过多线程技术，或者业余时间用过多线程写爬虫，提升效率。
‘‘‘
进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最
小单位，进程拥有自己独立的内存空间，所以进程间数据不共享，开销大。
线程： 调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在一个进程至少有一个线程，叫主线程，而多个线程共享内存(数据共享，共享全局变量)，从而极大地提高了程序的运行效率。
协程：是一种用户态的轻量级线程，协程的调度完全由用户控制。协程拥有自己的寄存器上下文和栈。
协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存
器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切
换非常快。
‘‘‘
同步：多个任务之间有先后顺序执行，一个执行完下个才能执行。 异步：多个任务之间没有先后顺序，可以同时执行有时候一个任务可能要在必要的时候获取另一个同时执行的任务的结果，这个就叫回调！ 阻塞：如果卡住了调用者，调用者不能继续往下执行，就是说调用者阻塞了。 非阻塞：如果不会卡住，可以继续执行，就是说非阻塞的。 同步异步相对于多任务而言，阻塞非阻塞相对于代码执行而言。
孤儿进程：父进程退出，子进程还在运行的这些子进程都是孤儿进程，孤儿进程将被 init 进程(进程号为 1)所收养，并由init进程对它们完成状态收集工作。
僵尸进程：进程使用fork创建子进程，如果子进程退出，而父进程并没有调用 wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中的这些进程是僵尸进程。 避免僵尸进程的方法：
-fork两次用孙子进程去完成子进程的任务；
-用wait()函数使父进程阻塞；
-使用信号量，在 signal handler 中调用waitpid，这样父进程不用阻塞。
‘‘‘
先要解析出baidu.com对应的ip地址
- 要先使用arp获取默认网关的mac地址
- 组织数据发送给默认网关(ip还是dns服务器的ip，但是mac地址是默认网关的mac地址)
- 默认网关拥有转发数据的能力，把数据转发给路由器
- 路由器根据自己的路由协议，来选择一个合适的较快的路径转发数据给目的网关
- 目的网关(dns服务器所在的网关)，把数据转发给dns服务器
- dns服务器查询解析出baidu.com对应的ip地址，并原路返回请求这个域名的client
得到了baidu.com对应的ip地址之后，会发送tcp的3次握手，进行连接
使用http协议发送请求数据给web服务器
- web服务器收到数据请求之后，通过查询自己的服务器得到相应的结果，原路返回给浏览器。
- 浏览器接收到数据之后通过浏览器自己的渲染功能来显示这个网页。
- 浏览器关闭tcp连接，即4次挥手结束，完成整个访问过程
‘‘‘
GET请求：
‘‘‘
请求的数据会附加在URL之后，以?分割URL和传输数据，多个参数用&连接。URL的
编码格式采用的是ASCII编码，而不是uniclde，即是说所有的非ASCII字符都要编码之后再传输。
‘‘‘
POST请求：
‘‘‘
POST请求会把请求的数据放置在HTTP请求包的包体中。上面的item=bandsaw就
是实际的传输数据。
因此，GET请求的数据会暴露在地址栏中，而POST请求则不会。
传输数据的大小：
- 在HTTP规范中，没有对URL的长度和传输的数据大小进行限制。但是在实际开发过程中，对
于GET，特定的浏览器和服务器对URL的长度有限制。因此，在使用GET请求时，传输数据会
受到URL长度的限制。
- 对于POST，由于不是URL传值，理论上是不会受限制的，但是实际上各个服务器会规定对POST
提交数据大小进行限制，Apache、IIS都有各自的配置。
安全性：
- POST的安全性比GET的高。这里的安全是指真正的安全，而不同于上面GET提到的安全方法
中的安全，上面提到的安全仅仅是不修改服务器的数据。比如，在进行登录操作，通过GET请求，
用户名和密码都会暴露再URL上，因为登录页面有可能被浏览器缓存以及其他人查看浏览器的
历史记录的原因，此时的用户名和密码就很容易被他人拿到了。除此之外，GET请求提交的数据
还可能会造成Cross-site request frogery攻击。
‘‘‘
效率：GET比POST效率高。
‘‘‘
POST请求的过程：
1.浏览器请求tcp连接（第一次握手）
2.服务器答应进行tcp连接（第二次握手）
3.浏览器确认，并发送post请求头（第三次握手，这个报文比较小，所以http会在此时进行
第一次数据发送）
4.服务器返回100 continue响应
5.浏览器开始发送数据
6.服务器返回200 ok响应
GET请求的过程：
1.浏览器请求tcp连接（第一次握手）
2.服务器答应进行tcp连接（第二次握手）
3.浏览器确认，并发送get请求头和数据（第三次握手，这个报文比较小，所以http会在此时
进行第一次数据发送）
4.服务器返回200 OK响应
‘‘‘
‘‘‘
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的cookie并进行cookie欺骗考虑到安全应当使
用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用服务器的性能考虑到减轻服
务器性能方面，应当使用cookie。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
5、建议： 将登陆信息等重要信息存放为SESSION 其他信息如果需要保留，可以放在cookie中
‘‘‘
‘‘‘
通过状态码告诉客户端服务器的执行状态，以判断下一步该执行什么操作。
常见的状态机器码有：
100-199：表示服务器成功接收部分请求，要求客户端继续提交其余请求才能完成整个处理过程。
200-299：表示服务器成功接收请求并已完成处理过程，常用200（OK请求成功）。
300-399：为完成请求，客户需要进一步细化请求。302（所有请求页面已经临时转移到新的url）。
304、307（使用缓存资源）。
400-499：客户端请求有错误，常用404（服务器无法找到被请求页面），403（服务器拒绝访问，
权限不够）。
500-599：服务器端出现错误，常用500（请求未完成，服务器遇到不可预知的情况）。
‘‘‘
‘‘‘
HTTP协议传输的数据都是未加密的，也就是明文的，因此使用HTTP协议传输隐私信息非常不安
全，为了保证这些隐私数据能加密传输，于是网景公司设计了SSL（Secure Sockets Layer）协议用于
对HTTP协议传输的数据进行加密，从而就诞生了HTTPS。简单来说，HTTPS协议是由SSL+HTTP协
议构建的可进行加密传输、身份认证的网络协议，要比http协议安全。
HTTPS和HTTP的区别主要如下：
1、https协议需要到ca申请证书，一般免费证书较少，因而需要一定费用。
2、http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
3、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
4、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、
身份认证的网络协议，比http协议安全。
‘‘‘
‘‘‘
1. Host (主机和端口号)
2. Connection (链接类型)
3. Upgrade-Insecure-Requests (升级为 HTTPS 请求)
4. User-Agent (浏览器名称)
5. Accept (传输文件类型)
6. Referer (页面跳转处)
7. Accept-Encoding（文件编解码格式）
8. Cookie （Cookie）
9. x-requested-with :XMLHttpRequest (是 Ajax 异步请求)
‘‘‘
IP： 网络层 TCP/UDP： 传输层 HTTP、RTSP、FTP： 应用层协议
‘‘‘
标签：地址 申请 关系 请求头 http请求 pid 怎么 接受 负载均衡。
原文地址：https://www.cnblogs.com/ghylpb/p/12684450.html
