当前位置：首页 > news >正文

系统网站推广方案怎么做百度资源

news 2025/7/2 10:30:01

系统网站推广方案怎么做,百度资源,在局域网服务器建设网站教程,模仿茶叶的网站制作文章目录计算机内存分配进程与子进程流IO模型非阻塞IOIO多路复用网络IO模型简单的socket并发的socket 计算机内存分配一个32位，4G内存的计算机，内存使用分为两部分： 操作系统内核空间；应用程序的用户空间使用的操作系统不同&a…

文章目录

计算机内存分配
进程与子进程
流
IO模型
非阻塞IO
IO多路复用
网络IO模型
- 简单的socket
- 并发的socket

计算机内存分配

一个32位，4G内存的计算机，内存使用分为两部分：

操作系统内核空间；
应用程序的用户空间
使用的操作系统不同，分配方式不同；

进程与子进程

进程是操作系统中资源管理的最小单位，它是将静态程序加载到内存中的一次动态的执行，包括进程创建、进程调度、进程销毁；
每个进程有自己独有的内存（在用户空间内），进程的私有内存是相互独立的，且进程间无法直接通信；
不同进程间通信，可以采用队列、管道、信号、共享内存（内核空间内）等方式；
每个进程中可以创建一个或者多个线程，多个线程共享当前进程的部分内存资源，如代码、全局变量等；
进程的内存分布
比如上图中的shell脚本，运行时，shell是父进程，python3开启子进程，父进程会等待子进程退出；当关闭shell进程（父进程）时，python3子进程由init进程接管。
父进程中，当以fork()系统调用创建子进程时，子进程执行exit()系统调用退出后，内核中仍然存有子进程的信息，如pid, exit code, run time等，这些信息要等父进程通过wait/waitpid来回收，若一直未回收，则退出的子进程成为僵尸进程，一直占用系统资源。
僵持进程无法通过kill关闭，随着数量增多，系统资源耗尽，导致系统瘫痪。

流

可以进行IO（input输入、output输出）操作的内核对象；
如文件、管道、socket…
流的入口是fd (file descriptor)；

IO模型

阻塞IO，一直等待，不占用资源；无法同时处理多个任务；
用户进程发起读的系统调用，当内核中socket fd未就绪时，一直阻塞等待；
socket fd 就绪时，将内核中的socket数据拷贝到用户空间（拷贝期间阻塞等待）；
accept()阻塞
非阻塞IO，忙轮询，占用CPU；
应用程序不断轮询内核，对应的socket fd是否就绪，未就绪则返回（非阻塞）；
若已就绪，则拷贝内核中socket的数据到用户空间（阻塞）。
accept()不阻塞
IO多路复用，多个IO复用一个进程/线程，既可以阻塞等待不占用资源，又可以同时并发处理多个任务；
- linux 支持select， poll， epoll
- 应用程序通过系统调用让内核同时监控多个socket fd，一旦有网络事件发生，内核就遍历找到对应的socket，将其标记为可读，然后将所有的socket fd返回给应用程序；
- 应用程序遍历所有的fd，找到就绪的fd，通过系统调用复制对应socket的数据到用户空间；
异步IO;
应用程序发起异步read操作后，立即返回；
内核中的fd就绪，复制数据完成，触发信号通知应用程序；
全程无阻塞；
信号驱动IO
首先注册信号处理函数；
检查内核socket fd 是否就绪，未就绪直接返回；
已就绪，则内核发送信号给应用程序，触发信号处理函数；
信号处理函数，发起系统调用，从内核空间拷贝socket数据到用户空间（阻塞）；

非阻塞IO

忙轮询，占用CPU；
性能不如阻塞IO；
代码流程，不停地遍历所有的fd，查看是否就绪；

IO多路复用

多个IO复用一个进程/线程，既可以阻塞等待不占用资源，又可以同时并发处理多个任务；

select
- 最大连接数默认1024；
- 两次拷贝，先将所有的fd 从用户空间拷贝到内核空间，由内核监控是否有fd就绪（可读或可写），也就是有网络事件发生；一旦有fd就绪，则遍历所有的fd集合，找到对应的fd并将其标记为就绪态（可读、可写），然后将所有的fd（fd集合）从内核空间拷贝到用户空间，用户进程内遍历所有的fd，找出就绪的从进行读写；
- 两次遍历；
- 并发量大时，性能指数式下降；
- 代码流程：
poll，与select 没有本质的区别，只是连接数比select多；
- select 使用固定长度的 BitMap表示文件描述符集合，而poll 使用动态数组，以链表形式来组织，突破了 select 的文件描述符个数限制，还会受到系统文件描述符限制。
- select/poll 都是使用线性结构存储进程的 socket 集合，都需要遍历文件描述符集合来找到可读或可写的 socket，时间复杂度为 O(n)，而且也需要在用户态与内核态之间拷贝文件描述符集合。
epoll，高性能的IO多路复用（仅linux支持）
- 连接数更大，上限为进程的最大连接数；查看最大连接数cat /proc/sys/fs/file-max
- 内核中采用红黑树结构，可高效地增删查（O(logn)），仅返回就绪的fd；
- 将就绪的fd拷贝给用户进程，避免无用的遍历；
- 适合并发量大的场景，可以解决C10K问题（单台服务器并发1w），
- 操作流程，使用epoll_create 创建内核epoll对象；epoll_ctl将要监控的socket加入红黑树，内核检测到有网络事件发生，则将对应的socket 连接放入一个就绪链表中，并复制给用户空间（epoll_wait返回）;
- epoll支持水平触发和边缘触发，边缘触发效率更高；select/poll仅仅支持水平触发，即内核socket缓冲区有数据就绪，在数据没有被进程读取完之前，会多次通知进程来读取；而边缘触发则仅仅通知一次，需要进程一次性读取所有的数据。例如，当快递放入快递站点时，管理员可能给你打多个电话催促你取快递，这种通知多次的方式就是水平触发；而当快递放入快递柜时，就只给你发送一次短信，仅仅通知一次，这种仅仅通知一次的方式就是边缘触发。
- IO多路复用中有socket 就绪，并不一定可读、可写，此时为避免进程阻塞，需要结合非阻塞IO一起使用。

网络IO模型

基于socket网络通信
客户端与服务端建立连接的过程
- 客户端的socket对象调用connect((ip, port))；
- 服务器的网卡接收请求，并转发给OS ，实现TCP三次握手；同时在操作系统内核中维护两个队列，TCP半连接队列 & TCP全连接队列；半连接队列表示未完成三次握手，全连接队列表示完成三次握手，已完成socket连接；
- 内核从TCP全连接队列取出当前socket连接，存储到内核文件列表中，同时将其fd返回用户空间，存入进程数组；
- 应用程序中就可以拿着这个已连接的socket进行读写；
- 读/写时就对应阻塞IO、非阻塞IO、IO多路复用、异步IO、信号驱动的IO的情况；

下面以python3语言为例演示socket的使用。

简单的socket

同时只能处理一个客户端的请求。

server:

import socket
import time
import sys
import signal  # 注册信号的处理函数def handler(signum: int, frame):"""接收到SIGINT信号时，打印一句话，并退出进程"""print("received signal:", signum)sys.exit(0)# 注册信号的处理函数
signal.signal(signal.SIGINT, handler)  # 使用 Ctrl + C 发送SIGINT信号# 网络层使用Ipv4
# 传输层使用TCP
sock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 默认为阻塞的socket# 绑定ip
sock_server.bind(("localhost", 8000))
# 最多监听1000个连接
sock_server.listen(1000)  # 监听的socketwhile True:# TCP三次握手完成，接收socket连接conn, addr = sock_server.accept()  # accept阻塞 等待 socket连接就绪# 处理当前的socket连接，conn是已连接的socketprint("conn:", conn, addr)# 读 IO操作data = conn.recv(1024)  # 阻塞等待 内核中socket就绪，并拷贝数据到用户空间 print("received data:", data.decode())# 写 IO操作，拷贝到内核空间，写入socket缓冲区conn.send(b"hello, i am server. I have got your data.")# 在当前socket连接 的请求处理完之前，服务端不会接收下一个客户端的socket连接time.sleep(20)

client:

import socket
import time# 创建客户端
sock_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 建立连接
sock_client.connect(("localhost", 8000))# 发送数据
sock_client.send(b"hello, i am jack")
print("发送数据完成.")# 接收数据
data = sock_client.recv(1024) # 接收 1024 bytes    # 阻塞  内核fd未就绪->就绪  内核socket数据复制到用户空间
print("received data:", data.decode())

并发的socket

同时可以处理多个客户端的请求。

阻塞+多进程
- 随着请求数量的增多，子进程越来越多，（fork创建子进程复制父进程所有的资源）占用的系统资源越来越多，并发量大时会影响系统的性能，甚至导致系统崩溃；
- 多进程上下文的切换包括用户空间、内核空间，消耗系统性能；
- 所以并发量特别大时，多进程不是理想的方案。

# server.py
import socket
import os
import time
import sys
import signal  # 注册信号的处理函数
import multiprocessingdef handler(signum: int, frame):"""接收到SIGINT信号时，打印一句话，并退出进程"""print("received signal:", signum)sys.exit(0)# 注册信号的处理函数
signal.signal(signal.SIGINT, handler)  # 使用 Ctrl + C 发送SIGINT信号# 处理请求
def handle_request(conn, addr):print("subprocess:", os.getpid())print("conn:", conn, addr)flag = Falsewhile not flag:# 接收数据data = conn.recv(1024) # recv from kernelprint("received data:", data.decode())# 发送数据conn.send(b"I am server. I have got your data.")# 检测客户端的断开data = conn.recv(1024)print("客户端断开：", data.decode())if not data:conn.close()print("客户端已断开.")flag = Trueprint(f"{os.getpid()}子进程退出.")if __name__ == "__main__":# 网络层使用Ipv4# 传输层使用TCPsock_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 默认为阻塞的socket# 绑定ipsock_server.bind(("localhost", 8000))# 最多监听1000个连接sock_server.listen(1000)  # 监听的socketwhile True:# TCP三次握手完成，接收socket连接conn, addr = sock_server.accept()  # accept阻塞 等待 socket连接就绪# 父进程 阻塞等待连接print("创建子进程.")# 子进程处理 请求sub_process = multiprocessing.Process(target=handle_request, args=(conn, addr))sub_process.daemon = Truesub_process.start()# client.py
import socket
import time# 创建客户端
sock_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 建立连接
sock_client.connect(("localhost", 8000))# 发送数据
sock_client.send(b"hello, i am jack")
print("发送数据完成.")# 接收数据
data = sock_client.recv(1024) # 接收 1024 bytes
print("received data:", data.decode())sock_client.close() # 客户端断开连接，会发送空数据到服务端

阻塞+多线程
- 线程是轻量级进程，同一个进程的多个线程可以共享当前进程的部分资源（代码、全局变量等），避免了过多的资源消耗；
- 多线程的上下文切换，虽比多进程轻量，但大量的线程来回切换，也会给系统造成不小的开销；
- 多线程需要考虑线程安全问题，另外每个线程也有自己的栈空间，也消耗内存；大量的线程必然会消耗大量的栈空间；
- 所以对于特别大的并发量时，多线程也不是理想的方案。