记录面试技巧

1、基础

# 1、开机启动流程
    1. 按下电源
    2. BIOS自检  
    3. MBR主引导分区
    4. 进入GRUB菜单   
    5. 加载内核 Kernel
    6. systemd     init进程
    7. 读取运行级别   
    8. 初始化系统 
    9. 并行启动开机自启动的服务         串行启动  
    10. 运行getty文件，显示登陆界面 
 # 2、tcp、udp协议

   1、TCP/UDP 可靠/不可靠协议
    TCP — 传输控制协议 #必须建立双向通路
    UDP — 用户数据报协议 #传输效率高
    
   2、tcp的三次握手和4次挥手需要掌握 
# 3、LVM（ 逻辑卷管理）
    PV	#物理卷    硬盘    分区   
    VG	#卷组      多个硬盘 多个分区组成 
    LV	#逻辑卷	分区   逻辑分区
    需要掌握kvm扩容
# 4、mount挂载、网络路由、定时任务 （了解即可）
# 5、查看一些常规配置
    dns         cat /etc/resolv.conf 
    内核版本      uname -r
    cpu核数      lscpu 
    centos版本   cat /etc/redhat-release 
    路由         route -n
# 6、三剑客的区别
    grep更适合单纯的查找或匹配文本
    sed更适合编辑匹配到的文本
    awk更适合格式化文本，对文本进行较复杂格式处理。
# 7、状态码
    #正常页面    - 
    200   成功  
    204   成功，但是没有数据  
    301   永久重定向（跳转）  
    302   临时重定向（跳转）  
    304     本地缓存  
    307   内部重定向（跳转）  
    #客户端错误   -  
    400    客户端错误  
    401    认证失败  
    403   找不到主页，权限不足  
    404   找不到页面  
    405   HTTP 不被允许  
    416   所请求的范围无法满足  

    #服务端错误   -  
    500      内部错误  
    502     找不到后端主机  
    503   服务器过载  
	504   后端主机超时

2、架构

# 1、公司架构  LNMT（为主）  LNMP 
 
  自由发挥

# 2、nginx的优点
    1.Nginx技术成熟，具备的功能是企业最常使用而且最需要的
    2.适合当前主流架构趋势, 微服务、云架构、中间层
    3.统一技术栈, 降低维护成本, 降低技术更新成本。
    4、Nginx是一个开源且高性能、可靠的Http Web服务、代理服务。
        开源: 直接获取源代码
        高性能: 支持海量并发
        可靠: 服务稳定
    5、支持热部署（Epool网络模型）

# 3、nginx的三种方式： web服务器、反向代理、负载均衡
  正向代理： 正向代理代理客户端
  反向代理： 反向代理代理服务器
  
# 4、nginx和apache的区别

    1、二者最核心的区别在于apache是同步多进程模型，一个连接对应一个进程；nginx是异步的，多个连接（万级别）可以对应一个进程 。nginx处理静态文件好,耗费内存少.但无疑apache仍然是目前的主流,有很多丰富的特性.所以还需要搭配着来.当然如果能确定nginx就适合需求,那么使用nginx会是更经济的方式。

    2、nginx的负载能力比apache高很多。

    3、nginx处理动态请求是鸡肋，一般动态请求要apache去做，nginx只适合静态和反向。

    4、Apache在处理动态有优势，Nginx并发性比较好，CPU内存占用低，如果rewrite频繁，那还是Apache吧！

    5、一般来说，需要性能的web 服务，用nginx 。如果不需要性能只求稳定，那就apache 吧。
 # 5、负载均衡
     1.四层负载均衡
    所谓四层负载均衡指的是OSI七层模型中的传输层，那么传输层Nginx已经能支持TCP/IP的控制，所以只需要对客户端的请求进行TCP/IP协议的包转发就可以实现负载均衡，那么它的好处是性能非常快、只需要底层进行应用处理，而不需要进行一些复杂的逻辑

    2.七层负载均衡
    七层负载均衡它是在应用层，那么它可以完成很多应用方面的协议请求，比如我们说的http应用的负载均衡，它可以实现http信息的改写、头信息的改写、安全应用规则控制、URL匹配规则控制、以及转发、rewrite等等的规则，所以在应用层的服务里面，我们可以做的内容就更多，那么Nginx则是一个典型的七层负载均衡SLB

    3.四层和七层负载均衡的区别
    四层负载均衡数据包在底层就进行了分发，而七层负载均衡数据包则是在最顶层进行分发、由此可以看出，七层负载均衡效率没有四负载均衡高。
    但七层负载均衡更贴近于服务，如:http协议就是七层协议，我们可以用Nginx可以作会话保持，URL路径规则匹配、head头改写等等，这些是四层负载均衡无法实现的。

 # 注意：四层负载均衡不识别域名，七层负载均衡识别域名
 
    1.SLB		#阿里云
    2.LB		#青云
    3.CLB		#腾讯云
    4.ULB		#Ucloud
# 6、nginx和lvs的区别

# 7、负载均衡算法

    # 调度算法	       概述
    轮询	            按时间顺序逐一分配到不同的后端服务器(默认)
    weight	         加权轮询,weight值越大,分配到的访问几率越高
    ip_hash        	 每个请求按访问IP的hash结果分配,这样来自同一IP的固定访问一个后端服务器
    url_hash	     按照访问URL的hash结果来分配请求,是每个URL定向到同一个后端服务器
    least_conn	     最少链接数,哪个机器链接数少就分发给它

# 8、nginx常用模块

  核心模块：HTTP模块、EVENT模块和MAIL模块
  基础模块：HTTP Access模块、HTTP FastCGI模块、HTTP Proxy模块和HTTP Rewrite模块，
  第三方模块：HTTP Upstream Request Hash模块、Notice模块和HTTP Access Key模块。 
  # 详细信息： https://blog.csdn.net/qq_23893101/article/details/117136374
  
# 9、nginx优化
    1、CPU亲和、worker进程数、调整nginx进程打开的文件句柄数
    2、使用Epool网络模型、调整每个worker进程的最大连接数
    3、文件的高效读取sendfile、nopush
    4、文件的传输实时性、nodealy
    5、开启tcp长连接，以及长连接超时时间keepalive_timeout
    6、开启文件传输压缩gzip
    7、开启静态文件expires缓存
    8、隐藏nginx版本号
    9、禁止通过ip地址访问，禁止恶意域名解析，只允许域名访问
    10、配置防盗链、以及跨域访问
    11、防DOS、cc攻击，限制单IP并发连接，以及http请求
    12、优雅显示nginx错误页面
    13、nginx加密传输https优化
    14、nginx proxy_cache、fastcgi_cache、uwsgi_cache 代理缓存，第三方工具（squid、varnish）
 # 10、php优化
     # nginx
     硬件 nginx做代理⽐较消耗CPU、内存，nginx做静态资源管理⽐较消耗磁盘和IO；
     ⽹络 带宽，传输速率，是否丢包
     系统 调整⽂件描述符，time_wait重⽤
     应⽤ keepalive⻓连接
     服务 nginx管理静态资源 浏览器缓存、⽂件⾼效传输、压缩、防盗链、跨域访问、CPU亲和
     nginx做安全 nginx+lua 实现 waf 防⽕墙

    # php
     php.ini 访问错误⽇志，上传⽂件⼤⼩调整、session共享配置
     php-fpm 监听地址，动态调节php进程，启动⽇志
     php状态模块
     php慢查询
 # 11、keepalived （VRRP协议）
    'keepalived软件是基于VRRP协议实现的，VRRP虚拟路由冗余协议，主要用于解决路由单点故障问题
    VRRP协议：# 可生成VIP（虚拟IP）以及(VMAC)
    vrrp组：# 一个vrrp组由多台VRID协同工作的路由器组成
    vip负责IP漂移 # 把虚拟IP，转到备份的‘交换机’
    vmac 负责通知ARP广播修改mac地址。
    # 什么是VRRP虚拟路由冗余协议？
    ARP广播 ：# 我们在连接交换机的时候，需要广播。我们的电脑，上网需要以太网协议以及IP协议，根据arp协议判断源目标是否在同一lan,这时候需要广播请求给交换机做广播，这时候我们需要广播的MAC地址，不在同一LAN，我们需要路由器IP，让路由器帮我们转发。
    
# 12、keepalived 两种区别
    # 1，抢占式
    抢占模式为当keepalived的某台机器挂了之后VIP漂移到了备节点，当主节点恢复后主动将VIP再次抢回，keepalived默认工作在抢占模式下。
    主节点MASTER，备节点BACKUP

    # 2，非抢占式
    非抢占模式则是当主节挂了再次起来后不再抢回VIP。
    两个节点的state都必须配置为BACKUP，两个节点都必须加上配置 nopreempt。
# 13、防火墙 （重要的是会操作）
  # firewalld防火墙
  # 必须记住的三个区域，其他区域了解 
    trusted：白名单
    public：默认区域
    drop：黑名单
  # Iptables防火墙 （四表五链）
  #四表：
    filter表——过滤数据包
    Nat表——用于网络地址转换（IP、端口）
    Mangle表——修改数据包的服务类型、TTL、并且可以配置路由实现QOS
    Raw表——决定数据包是否被状态跟踪机制处理

    #五链：
    INPUT链——进来的数据包应用此规则链中的策略
    OUTPUT链——外出的数据包应用此规则链中的策略
    FORWARD链——转发数据包时应用此规则链中的策略
    PREROUTING链——对数据包作路由选择前应用此链中的规则（所有的数据包进来的时侯都先由这个链处理）
    POSTROUTING链——对数据包作路由选择后应用此链中的规则（所有的数据包出来的时侯都先由这个链处理）
# 14、自动化工具 （ansible）

    1. puppet 学习难，安装ruby环境难，没有远程执行功能
    2. ansible 轻量级，大规模环境下只通过ssh会很慢，串行的，也会有小量的并行。

    'ansible与saltstack的差别'
    # ansible  方便，只需要配置一个主机清单就可以一键执行         ---> 灰度发布
    # saltstack  超过200台机器，如果用ansible就比较慢了，因为ansible是串行的，是一台一台执行的，所以用saltstack。

# 15、ansible常用模块
    command             # 执行shell命令(不支持管道等特殊字符)
    shell               # 执行shell命令
    script              # 远程执行shell脚本
    yum_repository      # 配置yum仓库
    yum                 # 安装软件
    copy                # 变更配置文件
    file                # 创建目录或文件
    service             # 启动与停止服务
    systemd             # 启动与停止服务
    mount               # 挂载设备
    cron                # 定时任务
    get_url             #下载软件
    firewalld           #防火墙
    selinux             #selinux
    setup			   #获取主机信息

3、mysql （了解） – 重点见12

# 1、关系型和非关系型
    # 关系型：
        mysql、oracle、db2、sqlserver
        mariadb
     # 1、数据之间彼此有关系或者约束
     # 2、存储数据的编写形式通常是以表格存储
     # 3、支持事物
     # 4、存储在硬盘中

    # 非关系型：
        redis
        key.value
        memcache
        mongodb
    # 1、存储的方式是k、v形式存储，不支持事务
    # 2、是存储在内存（缓存）
    # 字符编码
    utf8mb4
    注：oracle特别好，但是特别费钱，一般大公司才会用

# 2、四种语言的区别
    #1、DDL语句    数据库定义语言： 数据库、表、视图、索引、存储过程，例如CREATE DROP ALTER
    #2、DML语句    数据库操作语言： 插入数据INSERT、删除数据DELETE、更新数据UPDATE、查询数据SELECT
    #3、DCL语句    数据库控制语言： 例如控制用户的访问权限GRANT、REVOKE（操作对象的权限）
    # 4、DQL语句   数据查询语言：   select查询表中的数据
# 3、四种数据库
    # information_schema： 
    虚拟库，不占用磁盘空间，存储的是数据库启动后的一些参数，如用户表信息、列信息、权限信息、字符信息等
    # performance_schema：
    MySQL 5.5开始新增一个数据库：主要用于收集数据库服务器性能参数，记录处理查询请求时发生的各种事件、锁等现象 
    # mysql：
    授权库，主要存储系统用户的权限信息
    # test：
    MySQL数据库系统自动创建的测试数据库

# 4、数据库的增删改查
    # 1、严格模式比较
    针对不同版本会出现不同效果
    5.6版本默认没有开启严格模式，规定只能存一个字符，你给多少字符，会自动截取
    5.7之后的版本开启了严格模式，规定几个字符就是，字符多了会报错
    Data too long for ..
    #严格模式到底开不开呢
    mysql5.7以后都是开启的；
    使用数据库准则：
    能尽量少让数据库干活就少干活，不要给数据库增加额外压力

    # 2、日期比较
    DATETIME的日期范围是1001——9999年（时间长，读写效率要慢）
    TIMESTAMP的时间范围是1970——2038年（时间短，但是效率快） #选择这个就好

    # 3、字符比较
    #char类型：定长，简单粗暴，浪费空间，存取速度快
    char的优缺点：存取速度比varchar更快，但是比varchar更占用空间

    #varchar类型：变长，精准，节省空间，存取速度慢
    varchar的优缺点：比char省空间。但是存取速度没有char快
    # charvr和char那个更省空间
    按道理来charvr更省空间，实际是分情况讨论的，
    字符个数小于4个，charvr更省空间，如果10000条记录，差不多9000多小于4个字符，cahrvr却更省空间
    字符个数正好4个，char却更省空间，如果10000条记录，差不多9000多正好等于4个字符，cahr却更省空间
    # 枚举类型与集合类型
    enum (单选 )只能在给定的范围内选一个值，如:性别 sex 男male/女female
    set (多选) 在给定的范围内可以选择一个或一个以上的值（爱好1,爱好2,爱好3…) 
    # 枚举类型与集合类型对比：
    1、集合可以写一个，但是不能写没有列举的
    2、枚举字段，后期存储数据的时候只能从枚举里面选择一个存储没有列举的
    
# 6、MySQL逻辑系统架构分为3层:
    #  应用层（连接层）
    #  MySQL服务层（SQL层）
    #  存储引擎层   --> innodb
    #  文件层（文件系统）
    ##### 1、连接层
    1.验证用户的身份，用户名密码是否匹配
    2.提供两种连接方式（TCP/IP连接、socket连接） # socket只能本地连接
    3.连接层提供了一个与sql层交互的线程
    ##### 2、SQL层
    1.接收连接层传来的SQL语句
    2.验证语法
    3.验证语义(DML,DDL,DCL,DQL) 检查你输入的SQL语句是 select insert update delete... grant
    4.解析器:解析你的SQL语句,生成多种执行计划
    5.优化器:接收解析器传来的多种执行计划,选择最优的一种
    6.执行器:将优化器选择出的最优的SQL,执行
        6.1 建立一个与存储引擎层 交互的线程
        6.2 将执行语句交给存储引擎层,取数据 接收存储引擎层,结构化成表的数据结果
    7.如果你的前端有缓存,写缓存（caches、buffers）
    8.记录日志(binlog)  ---解析sql语句
# 7、存储引擎层
    1.接收到SQL层传来的SQL语句
    2.与磁盘交互,取数据,结构化成表的形式,返回给SQL层
    3.建立一个与SQL层交互的线程
    # 存储引擎层就是硬件层

    mysql数据管理软件服务端           --》 存储引擎innodb  #用户态内存空间
    操作系统                        ---》 文件系统  # os cache
    计算机硬件                      ---》 硬盘   #硬盘结构

    2.什么是存储引擎
    mysql的文件系统，主要是与磁盘交互
    3、innodb与myisam的区别
    1.myisam是表级锁，InnoDB是行级锁
    2.myisam不支持事务，InnoDB支持事务
    3.myisam不支持CSR，InnoDB支持CSR #故障自动恢复（CSR）

    # 锁 当并发处理的数据的时候，只能一个成功，类似与抢票，只有一张票，多人同时抢，只能一个成功，锁是保证数据安全，但是会降低效率，所以要少用
    表空间 ibd文件  ---存放的数据
# 8、存储引擎
    mysql> show engines;  #查看搜索引擎

    InnoDB存储引擎 
    （必须有主键，如果没有  会自上而下找一个不为空且唯一的字段为主键），如果没有为自己添加一下隐藏的字段为主键，一般id为主键 # mysql5.5版本之后默认之后的存储引擎
    MEMORY存储引擎  # 内存引擎（数据全部存储在内存），断电即丢失
    BLACKHOLE存储引擎  # 黑洞，无论存什么都会丢失
    MyISAM存储引擎  # 存储在内存，# mysql5.5版本之后默认之前的存储引擎，速度要比innodb更快，但是我们追求的是安全
    InnoDB存储引擎（默认）：存在硬盘上
    存储引擎（读取表）就是mysql中的一个小插件，表的类型，每一种存储引擎，就有自己独特的处理表的方式，存储数据更加安全

    # 三大重要特性：
    Supports transactions   # 事务  要么全部执行成功，要么全部执行失败
    row-level locking       # 锁机制 （行级锁）缺点，并发高  # 前两个是安全的
    foreign keys            # 外键 （外键约束，数据和数据之间约束，防止脏数据出现）
    级联删除，级联增加 

    # mysiam存储引擎
            t1.frm：表结构
            t1.MYD：数据
            t1.MYI：索引
    # innodb存储引擎
            t2.frm：表结构
            t2.ibd：表数据+索引 （表空间）
    # mysql> create table t2(id int)engine=innodb;
    # mysql> create table t2(id int)engine=myisam; 其他存储引擎类似
    
# 9、innodb存储引擎执行流程
    # 三大阶段
    1、执行阶段（1,2,3,4)
      - sql数据加载到内存，写undo log，更新内存中数据，写redo log buffer
    2、事务提交阶段 (5,6,7)
      - redo log和binlog刷盘，commit标记写入redo log中
    3、最后(8)
      - 后台io线程随机把内存中脏数据刷到磁盘上
# 8个小步骤
    1. 把该行数据从磁盘加载到buffer pool中，并对该行数据进行加锁
    2. 写undo log
    3. 在buffer pool中的数据更新，得到脏数据  #还没有写到硬盘的数据是脏数据
    4. 把所作的修改写入到redo log buffer当中
    5. 准备提交事务redo log刷入磁盘  #redo log写的是修改后的数据 
    6. 准备提交事务binlog写入磁盘 #binlog写的是执行的信息
    7. 把binlog的文件名和位置写入commit（提交）标记，commit标记写入redolog中，事务才算提交成功；否则不会成功  #commit 提交
    8. IO线程Buffer Pool中的脏数据刷入磁盘文件，完成最终修改
    # 脏数据
     还没有写到硬盘的数据是脏数据

# 10、索引
    1、什么是索引
    1）索引就好比一本书的目录，它能让你更快的找到自己想要的内容。
    2）让获取的数据更有目的性，从而提高数据库检索数据的性能。
    # 索引是存储引擎中一种数据结构，或者说数据的组织方式，又称之为键key
      是存储引擎用于快速找到 记录的一种数据结构。
    2、为何用索引
    1、提升查询速度
    2、降低了写效率
    #  应用程序对数据的读写比例基本为10:1
    3、创建索引的两个步骤
      create index xxx on user(id);
      1、提取索引字段的值当作key，value就是对应的本行记录
      10 -------------> 10 zs
      7 --------------> 7 ls
      2、以key的为基础比较大小，生成树型结构
      leaf node：叶子节点
      non-leaf node：根节点、树枝节点
     4、如何正确看待索引
     1、项目上线前就提前考虑
     2、以什么字段的值为基础构建索引
     3、最好是不为空、唯一、占用空间小的字段
     4、索引不是越多越好，对于不必要的字段加索引，反而加大io负担
    # 1、当表中有大量数据存在的前提下，创建索引速度会很慢
    # 2、在创建索引完毕之后，对表读的性能会大幅度提升，但是会写的性能会很慢
        # 注：
    1、索引不要随意创建
    2、如果上线之后载想着加索引，光定位到索引身上就需要耗费很多时间，排查成本很高
    3、如果某一张表的ibd文件中创建了很多棵索引树，意味着很小的一个update语句，就会导致很多棵索引树需要发生变化，从而把硬盘IO打上去
    # 一个磁盘块存储的限制的
    为什么用id字段为索引
    占用空间少，一个磁盘块能够存储的数据多
    那么降低了树的高度，从而减少查询次数
    # 索引的根本原理就是把硬盘IO次数降下来

    5、索引到底是一种什么样的数据结构
    # 1、索引到底是一种什么样的数据结构：B+树
      二叉树、平衡二叉树、B树=》B+树

    #二叉树：
      左节点的key值小于当前节点的key，而右节点的key大于当前节点，但是不能提速  -- #三次查找
      create index idx_id on use(id);
      select * from user where id =100;

     # 平衡二叉树：
        左子树与右子树的高度差不超过1
     # 一次iO就读一次节点，就相当于一辆卡车，只拉一个快递(一个节点只读一个一页到内存)
        每个节点只放了一条数据，相当于innodb存储引擎共16k的数据只放了一条数据，几个字节，浪费了许多

     # B树：
          一次io读入内存是一页数据，或者叫一个磁盘块的数据，磁盘块里包含了n个节点
          ps：根节点页常驻内存 -- #两次查找
     问题：页中的节点既存放key又存放对应记录值（values --》对应的是一行的完整记录）

    # B+树：
        1、非叶子节点只放key（根、树枝节点放key），只有叶子节点才放key：value  --》非叶子节点能存放的key个数变多，衍生出指针越多，树会变得更矮更胖
        2、叶子节点也指针指向，是有序排列的，这意味着B+树在排序操作上有天然的优势（范围查询速度快）# （因为提前排好了，再次查找的时候不需要从头再找）--》叶子节点是双向连接的  
        select * from user where id > 18;
         先找到id=19所在的叶子节点，然后只需要根据叶子节点的链表指向向右查找下一个节点（id =19、id=20...）即不需要在回根节点查找
        3、叶子节点内的key值是单向链表，叶子节点和叶子节点之间是双向链表。即全都排好序了  --》排序会很快   
        4、一个页、一个磁盘块、一个节点固定大小16k，可以存放的数据量就很多
          安装每个节点存放1000数据来算，三层的B+树可以组织多少条数据1000  *1000 * 1000

        # 特点：
           1、B树只擅长等值查询
           2、B+树擅长等值查询、范围查询
    # 总结：
    只要叶子节点才是存放的数据是真实的，其他数据都是虚拟数据的
    树的层级越高，所经历的步骤就越多（树越高，查询的层级就越多）
    树越低越好，查询速度越快
    # 如果存1000个数据，那么三层B+树可以存放上10亿条数据 --------》 树的高度是几，那个n就是几 n的三次方

# 11、事务
1、什么是事务
    # 什么是事务
    顾名思义就是要做的事情，事务就相当于一个盛放sql的容器
    事务中的sql要么全部执行成功，要么所有已经修改的操作都回滚到原来的状态，即一条sql也别想成功
    # 作用
    保证了数据操作的安全性，一致性
2、如何使用事务
    # 事务相关的关键字
    # 1、开启事务
    # 2、回滚（回到事务执行之前的状态）
    rollback
    # 3、确认（确认之后就无法回滚了）
	commit
# 总结：
当你想让sql语句同时保证数据的一致性，要么同时成功，要么同时失败，那么就可以考虑使用事务

3、事务四大特性
ACID 四大特性 #ACID
    # A: 原子性 (Atomic)
    一个事务是一个不可分割的单位，事务中包含的诸多操作，要么同时失败，要么同时成功
    所有语句作为一个单元全部成功执行或全部取消。
    # C:一致性 （Consistent）
    事务必须是是数据库一致性的状态变成另外一个一致性的状态，一致性根原子性密切相关的,
    如果数据库在事务开始时处于一致状态，则在执行该事务期间将保留一致状态。
    # I：隔离性 (Isolated)
    一个事务的执行不能被其他事务干扰,事务之间不相互影响。
    # D：持久性 (Durable)
    也可以称为永久性，一个事务一旦提交成功执行成功，那么它就是对数据库中的数据修改是永久的
4、事务的三种模式
    1、自动提交事务（隐式开启、隐式提交） # 默认
    2、隐式事务\\（隐式开启、显式提交）
    2、隐式事务\\（隐式开启、显式提交） #开发
    # 注意，重要的事说三遍
    这种方式在当你使用commit或者rollback后，事务就结束了
    再次进入事务状态需要再次start transaction
    4、事务的保存点
    1、设置保存点savepoint 保存点名字
    2、回滚到某个保存点，该保存点之后的操作无效，rollback 某个保存点名
    3、取消全部事务，删除所有保存点rollback
    # 注意：rollback和commit都会结束掉事务，这之后无法再回退到某个保存点
5、数据库读现象
    # 读现象  --》 在并发场景下，并发的多个事务操作同一份数据，而产生的一些奇怪的独现象

    # 1.脏读  --》原因  -- 设置安全级别低导致的
    Dirty Reads，比如有两个事务并行执行操作同一条数据库记录，A事务能读取到B事务未提交的数据。
    # 2.不可重复读
    Non-Repeatable Reads，同样是两个事务在操作同一数据，如果在事务开始时读了某数据，这时候另一个事务修改了这条数据，等事务再去读这条数据的时候发现已经变了，这就是没办法重复读一条数据。
    # 3.幻读
    Phantom Read，与上方场景相同，事务一开始按某个查询条件没查出任何数据，结果因为另一个事务的影响，再去查时却查到了数据，这种就像产生幻觉了一样，被称作幻读。
# 总结
`脏读
指事务A读取到事务B修改但未提交事务的数据。
(事务B未执行commit的时候，但是事务A却读取到了)，硬盘的数据和读取的数据不一样
`不可重复读
每次读取的数据不一样，读一次数据，数据每次不一样）
    
# 12、锁
  顾名思义就是锁定的意思，修改数据时锁住数据，锁是一种保障数据的机制，如何保障?
  2、为什么用锁？
  以互斥锁为例,让多个并发的任务同一时间只有一个运行（注意这不是串行），牺牲了效率但换来数据安全
  在事务ACID特性过程中，“锁”和“隔离级别”一起来实现“I”隔离性的作用，并发写同一份数据的时候安全，保证数据安全
  3、锁的优缺点
      优点：保障并发场景下的数据安全
      缺点：降低了效率
      # 所以我们在使用锁时尽可能缩小锁的范围，即锁住的数据越少越好，并发能力越高
  4、锁的分类
      # 1、按锁的粒度划分，可分为行级锁、表级锁、页级锁。（mysql支持）
      # 2、按锁级别划分，可分为共享锁、排他锁
      # 3、按使用方式划分，可分为乐观锁、悲观锁
      # 4、按加锁方式划分，可分为自动锁、显式锁
      # 5、按操作划分，可分为DML锁、DDL锁
  5、行级锁
      # 行级锁  -->支持引擎：InnoDB
      行级锁是Mysql中锁定粒度最细的一种锁，表示只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小，但加锁的开销也最大。行级锁分为共享锁 和 排他锁。
      # 特点：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低，并发度也最高。
      行级锁定分为行共享读锁（共享锁）与行独占写锁（排他锁） 
      # 共享锁（S）：SELECT  FROM table_name WHERE ... LOCK IN SHARE MODE
      # 排他锁（X)：SELECT  FROM table_name WHERE ... FOR UPDATE 
      # 排它锁======== 等于========互斥锁
  6、锁的使用
      事务一对id=3的行加了互斥锁之后，其它事务对id=3行不能加任何锁（写不行，但是可以读）
      事务一对id=3的行加了共享锁之后，其它事务对id=3行只能加共享锁，或者不加锁（写不行，但可以读）
      排他锁：保证在多事务操作时，数据的一致性。(在我修改数据时，其他人不得修改) # X 排查锁 一般用于写数据
      共享锁：保证在多事务工作期间，数据查询时不会被阻塞。 # S 共享锁 一般用于读数据
    7、多版本并发控制（MVCC）
        乐观锁：多事务操作时，数据可以被同时修改，谁先提交，谁修改成功。
        悲观锁：多事务操作时，数据只有一个人可以修改。
        # 1）只阻塞修改类操作（排它锁），不阻塞查询类操作（共享锁）
        # 2）乐观锁的机制（谁先提交谁为准）
        # 在MVCC并发控制中，读操作可以分成两类：
          快照读 (snapshot read)与当前读 (current read)。
        # 1、乐观锁并未真正加锁，效率高。一旦锁的粒度掌握不好，更新失败的概率就会比较高，容易发生业务失败。
        # 2、悲观锁依赖数据库锁，效率低。更新失败的概率比较低。
    8、事务隔离级别
        1.RC: read committed  允许事务查看其他事务所进行的已提交更改 #读未提交
        2.RU: read uncommitted（独立提交），未提交读，允许事务查看其他事务所进行的未提交更改； #读提交
        3.RR: repeatable read  可重复读 InnoDB 的默认级别	#commit提交以后可能看不到数据变化，必须重新连接
        4.serializable：串行化:，将一个事务的结果与其他事务完全隔离  #如果一个事务没有提交，查询也不能查了
            # 我改微信头像时你不能看我的信息，我看你朋友圈的时候你不能发朋友圈、不能看朋友圈
 9、 innodb存储引擎的锁机制
    # 1、命中索引则通过索引锁定行，简称为锁索引
    命中中的是聚集索引，就通过聚集索引本身来锁定行即可
    id为主键
    select * from t1 where id = 3;

    命中中的是辅助索引，会先锁定辅助索引，然后再对应聚集索引中的节点
    name为辅助索引
    select * from t1 where name="egon";  -- "egon":10

    # 2、如果没有命中索引，会把所有的行都锁住，相当于表锁
     强调：命中了索引才会锁行，不是说有索引就锁行
     强调：条件中引用的索引字段，也不一定会命中
10、行级锁三种算法
     InnoDB有三种行锁的算法，都属于排他锁：
    # 1、Record Lock：单个行记录上的锁。
    # 2、Gap Lock：间隙锁，锁定一个范围，但不包括记录本身。GAP锁的目的，是为了防止同一事务的两次当前读，出现幻读的情况。
    当我们用范围条件而不是相等条件检索数据，并请求共享或排他锁时，InnoDB会给符合条件的已有数据记录的索引项加锁；
    对于键值在条件范围内但并不存在的记录，叫做“间隙（GAP)”，InnoDB也会对这个“间隙”加锁，这种锁机制就是所谓的间隙锁（Next-Key锁）。 
    # 例如
    例：假如employee表中只有101条记录，其depid的值分别是 1,2,...,100,101，下面的SQL：
    mysql> select * from emp where depid > 100 for update;是一个范围条件的检索，并且命中了索引，InnoDB不仅会对符合条件的empid值为101的记录加锁，也会对empid大于101（这些记录并不存在）的“间隙”加锁。
    复制代码
    # 3、Next-Key Lock：等于Record Lock结合Gap Lock，也就说Next-Key Lock既锁定记录本身也锁定一个范围，特别需要注意的是，InnoDB存储引擎还会对辅助索引下一个键值加上gap lock。
    对于行查询，innodb采用的都是Next-Key Lock，主要目的是解决幻读的问题，以满足相关隔离级别以及恢复和复制的需要。
 11、行锁优化建议
    # 1、尽可能让所有数据检索都通过索引来完成， 从而避免无索引行锁升级为表锁
    # 2、合理设计索引，尽量缩小锁的范围
    # 3、尽可能减少检索条件，避免间隙锁
    # 4、尽量控制事务大小，减少锁定资源量和时间长度
    # 5、尽可能低级别事务隔离

# 12、mysql 主从复制原理  

# 从库准备
（1）从库change master to 时，ip port user password binlog position写入到 master.info进行记录
（2）从库 start slave 时，会启动IO线程和SQL线程
# 同步的过程
1.从库的IO线程，读取master.info信息，获取主库信息并连接主库 
2.主库接收从库的链接请求后，会生成一个准备binlog DUMP的线程，来响应从库 
3.主库一旦有新的日志生成，会发送“信号”给主库的binlog dump线程，然后binlog dump线程会 读取binlog日志的更新 4.TP(传送)给从从库的IO线程
5.IO线程将收到的日志存储到了TCP/IP 缓存 
6.写入TCP/IP缓存后，立即返回ACK给主库 ，此时主库工作完成 
7.IO线程更新master.info文件binlog 文件名和postion 
8.IO线程将缓存中的数据，存储到relay-log日志文件,此时io线程工作完成 
9.从库SQL线程读取relay-log.info文件，获取到上次执行到的relay-log的位置，作为起点 
10.从库SQL线程基于从步骤9中获取到的起点，去中继日志relay-log.000001获取后续操作，在从 库回放relay-log 11.SQL线程回放完成之后，会更新relay-log.info文件，把当前操作的位置记入，作为下一次操作 的起点。
12. relay-log会有自动清理的功能。

# 精简版原理：

master服务器将数据的改变记录二进制binlog日志，当master上的数据发生改变时，则将其改变写入二进制日志中
slave服务器会在一定时间间隔内对master二进制日志进行探测其是否发生改变，如果发生改变，则开始一个I/OThread请求master二进制事件
i/o线程去请求主库 的binlog，并将得到的binlog日志写到relay log（中继日志） 文件中；
主库会生成一个 log dump 线程，用来给从库 i/o线程传binlog；
SQL 线程，会读取relay log文件中的日志，并解析成具体操作，来实现主从的操作一致，而最终数据一致；

# 13、MySQL优化
		硬件的优化
		网络的优化
		数据库内存，线程
		innodb内存优化
		存储引擎
		SQL优化
		
		explain，来查询SQL索引命中率
		优化索引
-----------------------------------------------------------------------------------------
    通过慢查询日志定位慢查询sql，然后优化相关
    explain 分析慢查询sql
    索引问题，如何优化索引，不支持函数索引，
    索引命中的问题
    mysql的引擎有哪几种，myisam和innodb各自的优缺点
    innodb的事务
    脏读（Dirty Reads）不可重复读（Non-Repeatable Reads）幻读（Phantom Reads）
    innodb的行锁详解
    关于死锁
    mysql雪崩
    # 详细： https://juejin.cn/post/6844904136601927687

4、k8s

# 0、docker常用命令
    https://blog.csdn.net/mm970919/article/details/118075877
    
# 1、Dockerfile常用指令
    FROM	# 镜像来源
    ADD		# 复制文件到镜像，支持tar包自动解压，强于COPY
    RUN		# 指定构建镜像时运行的命令
    ARG		# 用于指定传递给构建时的变量
    ENV		# 环境变量
    COPY	# 复制文件到镜像
    LABEL	# 为镜像添加元数据，不常用
    EXPOSE	# 制定与外界交互的端口
    VOLUME	# 用于指定持久化目录
    ONBUILD	# 镜像触发器，可触发基础镜像内的动作
    WORKDIR	# 工作目录，类似于cd后的初始路径
    CMD		# 指定容器运行时的默认命令，如启动命令

# 2、Docker 容器虚拟化的好处

    作为一种轻量级的虚拟化方式，Docker 在运行应用上跟传统的虚拟机的方式相比具有如下显著优势：
    # Docker 容器启动很快，启动和停止可以实现秒级，相比传统的虚拟机方式（分钟级）要快速很多。
    # Docker 容器对系统资源需求很少，一台主机上可以同时运行数千个 Docker 容器。
    # Docker 通过类似 git 设计理念的操作来方便用户获取、分发和更新应用镜像，存储复用，增量更新。
    # Docker 通过 Dockerfile 支持灵活的自动化创建和部署机制，可以提高工作效率，并标准化流程。
    docker是利用宿主机的内核，vm需要centos ，docker不需要虚拟机一样重新加载一个操作系统，启动是秒级的
    # docker和虚拟机技术的不同：
    1、传统虚拟机,虚拟出一条硬件,运行一个完整的操作系统，然后在这个系统上安装和运行软件
    2、容器内的应用之间运行在宿主机的内容，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
    3、每个容器间是互相隔离，每个容器内都有一个属于自己的文件系统，互不影响

# 3、k8s常规组件
    # 1.API Server（kube-apiserver ：中央管理器，调度管理集群） == 领导（不干活）
    负责处理来自用户的请求，其主要作用就是对外提供RESTful的接口
    包括用于查看集群状态的读请求以及改变集群状态的写请求，也是唯一一个于etcd集群通信的组件。

    # 2.Controller（kube-controller-manager ：控制器： 管理容器，监控容器） == 安装人干活
    管理器运行了一系列的控制器进程，这些进程会按照用户的期望状态在后台不断地调节整个集群中的对象
    当服务的状态发生改变，控制器就会发现这个改变并且开始向目标状态迁移。

    # 3.Scheduler（kube-scheduler：调度器：调度容器）== 具体通过算法让某一个干活
    调度器其实为Kubernetes中运行的Pod选择部署的Worker节点
    它会根据用户的需要选择最能满足请求的节点来运行Pod，它会在每次需要调度Pod时执行。

    # 4.Flannel(提供集群间网络)

    # 5.Etcd(数据库)  == 存放的信息
    负载存储集群中各种资源对象的信息

    # 6.kubelet(部署容器，监控容器)

    # 7.kube-proxy(提供容器间的网络)
    # 8.DNS (域名解析)

# 4、常用控制器以及特点
    Deployment：       无状态应用部署，比如微服务，提供多副本等功能
    StatefulSet：      有状态应用部署，比如redis，提供稳定的存储、网络等功能
    DaemonSet：        守护型应用部署，比如日志收集组件，在每个机器都运行一份
    Job/CronJob：      定时任务部署， 比如垃圾清理组件，可以在指定时间运行
    
    etcd 是兼具一致性和高可用性的键值数据库，可以作为保存 Kubernetes 所有集群数据的后台数据库。
    可以定位成一个可信赖的分布式键值存储，键值对数据库，存储k8s集群重要信息（持久化数据）

    ingress controller: 官网只能实现4层代理，但是ingress可以实现7曾代理

    federation： 提供一个可以跨集群中心多k8s统一管理功能

    replicaset 不支持rolling-update（滚动更新），deployment支持滚动更新

    statefulset 有状态服务
    1、稳定的持久化存储  pod重新调度后还能访问到相同的持久化数据，基于PVC实现
    2、稳定的网络标志    pod重新调度后podname和hostname不变，基于headless service实现
    3、有序部署，有序扩展  从0-1逐步实现，有严格的启动顺序
    4、有序收缩，有序删除

    daemonset 保证一个node运行一个pod副本

    1、 node节点上运行日志收集daemon： fluented logsrash
    2、node节点上运行监控daemon: prometheus 
    3、运行集群存储daemon： ceph
    
 # 5、svc类型
    ClusterIP		# 向集群内部暴露服务
    NodePort		# 通过宿主主机IP和端口向外部暴露服务
    LoadBalancer	# 通过弹性IP向外部暴露服务
    ExtennalName	# 将外部的一个服务定义一个集群内部的别名
 # 6、ingress原理
 	根据ingress配置清单，实时生成Nginx配置，并且使其生效，之后通过nginx反向代理转发流量到pod中
 	 实际上，Ingress相当于一个7层的负载均衡器，是kubernetes对反向代理的一个抽象，它的工作原理类似于Nginx，可以理解成在Ingress里建立诸多映射规则，Ingress Controller通过监听这些配置规则并转化成Nginx的反向代理配置 , 然后对外部提供服务。
 # 7、nginx Ingress (基于域名的网络转发资源)
   1、 nginx ingress  :  性能强
   2、traefik ：原生支持k8s
   3、istio : 服务网格，服务流量的治理
 # 8、Pod的生命周期
    1.调度服务到节点
    2.创建Pod
    2.创建主容器
    3.依次创建业务容器
    4.执行开始回调钩子
    5.进行健康检查：存活探测、就绪探测
    6.执行结束回调钩子
    7.依次结束业务容器
    8.结束主容器
    9.销毁Pod

 # 9、K8s组件及协同关系
    所有服务均是由Apiserver调度
    1.Kubectl发送了一个部署nginx的任务
    2.进入Master节点进行安全认证
    3.通过认证后，Apiserver接受指令
    4.将部署的命令数据记录到ETCD中
    5.Apiserver再读取ETCD中的数据
    6.Apiserver找到Scheduler，告诉它要部署服务
    7.Scheduler向Apiserver调取工作节点数据，看部署在哪台合适
    8.Apiserver调取ETCD中粗出的数据，并发送给Scheduler
    9.Scheduler通国计算比较，找到最合适的Node节点并发送给Apiserver
    10.Apiserver把要部署在Node节点的计划储存到ETCD中
    11.Apiserver读取ETCD中的部署计划，通知Node节点的Kubelet来部署容器
    12.Kubelet根据指令部署Nginx容器，kube-proxy为Nginx容器创建网桥
    13.容器网桥部署完成后，Kubelet通知Apiserver已完成部署工作
    14.Apiserver将部署状态存储在ETCd中，同时通知Controller-Manager来活了
    15.Controller-Manager向Apiserve要需监控容器的数据
    16.Apiserver找ETCD读取相应数据，同时通知Kubelet要源源不断发送监控的数据
    17.Apiserver找Kubelet发送来的数据存储到ETCD中
    18.Apiserver将ETCD的数据返回给Controller-Manager
    19.Controller-Manager根据数据计算判断容器是否存在或健康
  # 10、K8s存储卷
      empyDir   # Pod调度到节点时创建的一个临时空目录，Pod删除随之删除，用于容器间分享文件
      hostPath  # 节点存储卷，挂在宿主机的文件或目录到Pod中
      PV/PVC    # 是外部存储系统中的一块存储空间，具有持久性，生命周期独立于Pod
      StoageClass # 是充当PV的模板，从而可以动态创建所需的PV，自动构建相对应的PV持久化存储卷
      configmap   # 能使一个配置文件多台机器共用，杜绝重复修改，支持热更新，且支持挂载
      两种方式：挂载、存储卷
      secret      # 将密码转换为密文，写入配置清单中，起到加密的作用。
  # 11、微服务网格Istio
      通过负载均衡、服务间的身份验证、监控等方法，istio可以轻松地创建一个已经部署了服务的网络，而服务的代码只需很少更改甚至无需更改，通过在整个环境中部署一个特殊的sidecar代理为服务添加istio的支持，而代理会拦截微服务之间的所有网络通信，然后使用其控制平面的功能来配置和管理istio，这包括：

    # 1、为 HTTP、gRPC、WebSocket和TCP流量自动负载均衡。
    # 2、通过丰富的路由规则、重试、故障转移和故障注入对流量行为进行细粒度控制。
    # 3、可插拔的策略层和配置API，支持访问控制、速率限制和配额。
    # 4、集群内（包括集群的入口和出口）所有流量的自动化度量、日志记录和追踪。
    # 5、具有强大的基于身份验证和授权的集群中实现安全的服务间通信。
    
    Istio IngressGateway 属于 8s ingress的加强版，可以指定复杂的流量路由规则，如流量拆分或流量镜像等，而且将l4-l6与l7解耦，而且可以从控制平面进行配置。
 # 12、istio的核心特性
     # 流量管理
    istio简单的规则配置和流量路由允许你控制服务之间的流量和API调用过程。istio简化了服务级属性（如熔断器、超时和重试）的配置，并且让它轻而易举的执行重要的任务（如 A/B 测试、金丝雀发布和按流量百分比划分的分阶段发布）。有了更好的对流量的可视性和开箱即用的故障恢复特性，这样就可以在问题产生之前捕获它们，无论面对什么情况都可以使调用更可靠，网络更健壮。详细内容参考后面流量管理章节。

    # 安全
    istio的安全特性解放了开发人员，使其只需要专注于应用程序级别的安全。istio提供了底层的安全通信通道，并为大规模的服务通信管理认证、授权和加密。有了istio，服务通信在默认情况下就是受保护的，可以让你在跨不同协议和运行时的情况下实施一致的策略，而所有这些都只需要很少甚至不需要修改应用程序。istio是独立于平台的，可以与Kubernetes（或基础设施）的网络策略一起使用。但它更强大，能够在网络和应用层面保护pod到pod或者服务到服务之间的通信。详细内容参考后面安全章节。

    # 可观察性
    istio健壮的追踪、监控和日志特性让你能够深入的了解服务网格部署。通过istio的监控能力，可以真正的了解到服务的性能是如何影响上游和下游的；而它的定制Dashboard 提供了对所有服务性能的可视化能力，并让你看到它如何影响其他进程。istio的Mixer（Mixer在istio1.5版本已经废弃了，功能整合到了istiod中） 组件负责策略控制和遥测数据收集。它提供了后端抽象和中介，将一部分istio与后端的基础设施实现细节隔离开来，并为运维人员提供了对网格与后端基础实施之间交互的细粒度控制。所有这些特性都使你能够更有效地设置、监控和加强服务的SLO。当然，底线是你可以快速有效地检测到并修复出现的问题。详细内容参考后面可观察行章节。

    # 平台支持
    istio独立于平台，被设计为可以在各种环境中运行，包括跨云、内部环境、kubernetes、Mesos等等。你可以在Kubernetes或是装有Consul的Nomad环境上部署 istio。istio 目前支持：

    Kubernetes上的服务部署
    基于Consul的服务注册
    服务运行在独立的虚拟机上
    # 整合和定制
    Istio的策略实施组件可以扩展和定制，与现有的ACL、日志、监控、配额、审查等解决方案集成。

5、监控

6、ceph

7、python

8、其他

# pms 床位管理系统
# oa  管理合同的系统
# 定时任务管理系统  代码发布系统
# mysql管理系统  阿波罗配置中心
# 员工管理系统


镜像 拉取不下来

DNS  私有仓库  网络  

9、面试题