进程之select和epoll

select 只能同时处理1024个客户端，多线程会回遇到资源瓶颈，什么才是解决高并发最有效的方式呢？

linux中提供了epoll这种多路复用的IO模型，注意其他平台没有相应的实现，所以epoll仅在linux中可用。

程序阻塞过程分析：

假设系统目前运行了三个进程ABC

进程A正在运行一下socket程序

server = socket.socket()
server.bind(("127.0.0.1",1688))
server.listen()
server.accept()

1.系统会创建文件描述符指向一个socket对象 ,其包含了读写缓冲区,已经进行等待队列

2.当执行到accept / recv 时系统会讲进程A 从工作队列中移除

3.将进程A的引用添加到 socket对象的等待队列中

 

进程的唤醒：

1.当网卡收到数据后会现将数据写入到缓冲区

2.发送中断信号给CPU

3.CPU执行中断程序,将数据从内核copy到socket的缓冲区

4.唤醒进程,即将进程A切换到就绪态,同时从socket的等待队列中移除这个进程引用

select 监控多个socket：

select的实现思路比较直接

1.先将所有socket放到一个列表中

2.遍历这个列表将进程A 添加到每个socket的等待队列中，然后阻塞进程。

3.当数据到达时，cpu执行中断程序将数据copy给socket同时唤醒处于等待队列中的进程A

为了防止重复添加等待队列，还需要移除已经存在的进程A

4.进程A唤醒后，由于不清楚哪个socket有数据，所以需要遍历一遍所有socket列表。

过程：

1.select需要遍历socket列表，频繁的对等待队列进行添加移除操作

2.数据到达后还需要给变量所有socket才能获知哪些socket有数据

两个操作消耗的时间随着要监控的socket的数量增加而大大增加

处于效率考虑才规定了最大只能监视1024个socket。

epoll：

1.避免频繁的对等待队列进行操作

2.避免遍历所有socket

每次处理完一次读写后，都需要将所用过程重复一遍，包括移除进程，添加进程，默认就会将进程

添加到等待队列，并阻塞住进程，然而等待队列的更新操作并不频繁

所以epoll采取的方案是，将对等待队列的维护和阻塞进程这两个操作进行拆分。

import socket,select
server = socket.socket()
server.bind(("127.0.0.1",1688))
server.listen(5)

#创建epoll事件对象，后续要监控的事件添加到其中
epoll = select.epoll()
#注册服务器监听fd到等待读事件集合
epoll.register(server.fileno(), select.EPOLLIN)

# 等待事件发生
while True:
    for sock,event in epoll.poll():
    pass

在epoll中register与unregister函数用于维护等待队列

epoll.poll则用于阻塞进程

第二个问题是select中进程无法获知哪些socket是有数据的所以需要遍历

epol为了解决这个问题,在内核中维护了一个就绪列表,

1.创建epoll对象,epoll也会对应一个文件,由文件系统管理

2.执行register时,将epoll对象 添加到socket的等待队列中

3.数据到达后,CPU执行中断程序,将数据copy给socket

4.在epoll中,中断程序接下来会执行epoll对象中的回调函数,传入就绪的socket对象

5.将socket,添加到就绪列表中

6.唤醒epoll等待队列中的进程,

进程唤醒后,由于存在就绪列表,所以不需要再遍历socket了,直接处理就绪列表即可

 

解决了这两个问题后,并发量得到大幅度提升,最大可同时维护上万级别的socket

epoll相关函数：

import select 导入select模块

epoll = select.epoll() 创建一个epoll对象

epoll.register(文件句柄,事件类型) 注册要监控的文件句柄和事件

事件类型:

select.EPOLLIN    可读事件

select.EPOLLOUT   可写事件

select.EPOLLERR   错误事件

select.EPOLLHUP   客户端断开事件

epoll.unregister(文件句柄)   销毁文件句柄

epoll.poll(timeout)  当文件句柄发生变化，则会以列表的形式主动报告给用户进程,timeout

为超时时间，默认为-1，即一直等待直到文件句柄发生变化，如果指定为1

 那么epoll每1秒汇报一次当前文件句柄的变化情况，如果无变化则返回空

epoll.fileno() 返回epoll的控制文件描述符(Return the epoll control file descriptor)

epoll.modfiy(fineno,event) fineno为文件描述符 event为事件类型  作用是修改文件描述符所对应的事件

epoll.fromfd(fileno) 从1个指定的文件描述符创建1个epoll对象

epoll.close()   关闭epoll对象的控制文件描述符

#coding:utf-8
#客户端
#创建客户端socket对象
import socket
clientsocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#服务端IP地址和端口号元组
server_address = ('127.0.0.1',1688)
#客户端连接指定的IP地址和端口号
clientsocket.connect(server_address)


while True:
    #输入数据
    data = raw_input('please input:')
    if data == "q":
        break
    if not data:
      continue
    #客户端发送数据
    clientsocket.send(data.encode("utf-8"))
    #客户端接收数据
    server_data = clientsocket.recv(1024)
    print ('客户端收到的数据：',server_data)
#关闭客户端socket
clientsocket.close()

服务器:
# coding:utf-8
import socket, select

server = socket.socket()
server.bind(("127.0.0.1", 1688))
server.listen(5)

msgs = []


fd_socket = {server.fileno(): server}
epoll = select.epoll()
# 注册服务器的 写就绪
epoll.register(server.fileno(), select.EPOLLIN)

while True:
    for fd, event in epoll.poll():
        sock = fd_socket[fd]
        print(fd, event)
        # 返回的是文件描述符 需要获取对应socket
        if sock == server:  # 如果是服务器 就接受请求
            client, addr = server.accept()
            # 注册客户端写就绪
            epoll.register(client.fileno(), select.EPOLLIN)
            # 添加对应关系
            fd_socket[client.fileno()] = client

        # 读就绪
        elif event == select.EPOLLIN:
            data = sock.recv(2018)
            if not data:
                # 注销事件
                epoll.unregister(fd)
                # 关闭socket
                sock.close()
                # 删除socket对应关系
                del fd_socket[fd]
                print(" somebody fuck out...")
                continue

            print(data.decode("utf-8"))
            # 读完数据 需要把数据发回去所以接下来更改为写就绪=事件
            epoll.modify(fd, select.EPOLLOUT)
            #记录数据
            msgs.append((sock,data.upper()))
        elif event == select.EPOLLOUT:
            for item in msgs[:]:
                if item[0] == sock:
                    sock.send(item[1])
                    msgs.remove(item)
            # 切换关注事件为写就绪
            epoll.modify(fd,select.EPOLLIN)

#coding:utf-8
#客户端
#创建客户端socket对象
import socket
clientsocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#服务端IP地址和端口号元组
server_address = ('127.0.0.1',1688)
#客户端连接指定的IP地址和端口号
clientsocket.connect(server_address)


while True:
    #输入数据
    data = raw_input('please input:')
    if data == "q":
        break
    if not data:
      continue
    #客户端发送数据
    clientsocket.send(data.encode("utf-8"))
    #客户端接收数据
    server_data = clientsocket.recv(1024)
    print ('客户端收到的数据：',server_data)
#关闭客户端socket
clientsocket.close()

服务器:
# coding:utf-8
import socket, select

server = socket.socket()
server.bind(("127.0.0.1", 1688))
server.listen(5)

msgs = []


fd_socket = {server.fileno(): server}
epoll = select.epoll()
# 注册服务器的 写就绪
epoll.register(server.fileno(), select.EPOLLIN)

while True:
    for fd, event in epoll.poll():
        sock = fd_socket[fd]
        print(fd, event)
        # 返回的是文件描述符 需要获取对应socket
        if sock == server:  # 如果是服务器 就接受请求
            client, addr = server.accept()
            # 注册客户端写就绪
            epoll.register(client.fileno(), select.EPOLLIN)
            # 添加对应关系
            fd_socket[client.fileno()] = client

        # 读就绪
        elif event == select.EPOLLIN:
            data = sock.recv(2018)
            if not data:
                # 注销事件
                epoll.unregister(fd)
                # 关闭socket
                sock.close()
                # 删除socket对应关系
                del fd_socket[fd]
                print(" somebody fuck out...")
                continue

            print(data.decode("utf-8"))
            # 读完数据 需要把数据发回去所以接下来更改为写就绪=事件
            epoll.modify(fd, select.EPOLLOUT)
            #记录数据
            msgs.append((sock,data.upper()))
        elif event == select.EPOLLOUT:
            for item in msgs[:]:
                if item[0] == sock:
                    sock.send(item[1])
                    msgs.remove(item)
            # 切换关注事件为写就绪
            epoll.modify(fd,select.EPOLLIN)

数据库：

什么是数据库？

数据库就是存储数据的仓库

存储数据的方式1：

变量然而变量的存储介质是内存，内存中的数据在断电后就消失了，无法永久保存。

很明显这是不行的，比如用户刚刚注册成功的用户名密码必须要永久

存储数据的方式2：

使用文件来存储数据就可以实现永久存储，但是文件是存储于硬盘上的，首先要考虑的就是效率问题，一个应用程序之所以效率低就是因为IO操作多。

另外还要考虑另外一个问题

不可能所有组件运行在同一台计算机上，因为一台计算机的性能总归有上限，例如淘宝双11，双12用一台计算机来做服务器的配置再高都肯定吃不消，那怎么办？

计算机的性能进行扩展：

 

1.垂直扩展：

不断的提升硬件性能，不可取

2.横向扩展（分布式计算）

添加更多的计算机，将程序的不同组件分别运行在不同的计算机上。

带来的优点：

性能提高，稳定性提高（可插拔式）

现在性能问题已经解决了，通过分布式的方式。

但是这些组件虽然分布在各个计算机上，但是它们还是一个整体

也就是说你操作的数据文件还是同一份

默认情况下，程序能访问的数据，就只是当期计算机。

访问不同计算机上的文件数据

如何能访问别的计算机上的文件呢? 

只有一种办法,通过网络 通过网络把你要什么数据告诉服务器 服务器在通过网络把你要的数据发送给你,得需要使用socket ,需要配套的来一个服务器端 和 客户端程序，把客户端程序分发给各个python程序 python程序通过客户端来链接服务器端 从而完成数据的读写

也就是说数据库本质上就是一套C/S结构的TCP程序

我们完全可以自己来编写这么一套软件，但是需要考虑一下几个问题

1.socket需不需实现并发? 必须要

2.既然是并发 还要考虑线程安全问题?     需要给文件操作加锁 

3.是不是任何计算机请求链接我都要接受呢? 不是需要进行用户认证 

4.单纯的对本地计算机上的数据进行读取 速度都是非常慢的硬盘上的数据有寻道寻址时间 平均延迟时间，速度太慢! 要想办法提高数据的存取效率，通过索引。

到现在我们知道了要开发一款应用程序必须先解决上述四个问题，但是对于每一个公司而言，开发周期是非常重要的，不可能为了开发应用程序而先花大把时间来编写数据库程序，这便产生了专门的数据库软件厂商。写出了专门的数据库软件。

常见的数据库：

关系型数据库：

数据库可以为数据与数据之间建立关联关系，人是一条数据，他可能关联着一个工作岗位数据。双方可以通过自身找到对方

（mysql 免费开源 支持中大型企业 为了防止mysql被闭源 以及 担心oracle的优化能力 创始人Widenius 另起灶炉 开发了mariaDB mariaDB 完全兼容mysql 使用起来 一模一样 mysql的一生 坎坎坷坷 先后被 sun - oracle收购 oracle 收费闭源 功能强大 分布式数据库 SQLServer 微软生态圈 仅支持 windows系统 太局限 DB2 IMB 开发的数据库软件 收费闭源 经常与IMB的机器绑定销售 打折啥的）

非关系型：

通关key value存储数据各个数据之间没有关系 不是通用性数据库 有局限性，通常运行在将数据存储在内存中，以提高速度，所以非关系性数据库多用于缓存，与关系型数据库搭配使用。

总结：我们通常所说的数据库就是一套软件，有服务端和客户端用来操作服务端上的文件

数据库相关概念

数据：

　　用于记录事物的状态信息，可以是数字，字符，声音图像等等

　　如name = jerry

记录：

　　一条记录用于保存一个事物的典型特征  就相当于文件中的一行

如jerry,180,man,帅

表:

本质就是一个文件，创建表的时候其实就是在创建一个文件 ，可以在数据库目录下看到

可不可能把所有数据全放到同一个文件里?

为了降低耦合性 方便管理 都应该把数据分门别类 放到不同文件中 

库:

就是一个文件夹

DBMS:

数据库管理软件 就是一个套接字服务器端软件

数据库服务器:

运行有数据库管理软件的计算机

在公司我们开发者关心的部分是哪些?

从库往上的需要我们关心  DBMS 和 服务器是运维关心的

 

 

epoll相关函数

import select 导入select模块
​
epoll = select.epoll() 创建一个epoll对象
​
epoll.register(文件句柄,事件类型) 注册要监控的文件句柄和事件
​
事件类型:
​
　　select.EPOLLIN    可读事件
​
　　select.EPOLLOUT   可写事件
​
　　select.EPOLLERR   错误事件
​
　　select.EPOLLHUP   客户端断开事件
​
epoll.unregister(文件句柄)   销毁文件句柄
​
epoll.poll(timeout)  当文件句柄发生变化，则会以列表的形式主动报告给用户进程,timeout
​
                     为超时时间，默认为-1，即一直等待直到文件句柄发生变化，如果指定为1
​
                     那么epoll每1秒汇报一次当前文件句柄的变化情况，如果无变化则返回空
​
epoll.fileno() 返回epoll的控制文件描述符(Return the epoll control file descriptor)
​
epoll.modfiy(fineno,event) fineno为文件描述符 event为事件类型  作用是修改文件描述符所对应的事件
​
epoll.fromfd(fileno) 从1个指定的文件描述符创建1个epoll对象
​
epoll.close()   关闭epoll对象的控制文件描述符