目录

java核心：

常用集合与数据结构: 

        单例集合:

        双列集合: 

线程安全的集合: 

     ConcurrentHashMap集合:

        HashTable集合:

CopyOnWriteArrayList集合:

CopyOnWriteArraySet集合:

ConcurrentLinkedQueue队列:

ConcurrentSkipListMap和ConcurrentSkipListSet：

数据类型: 

数据结构: 

树: 

B树(B-tree): 

B+树: 

mysql：

MVCC:

索引:

SQL优化:         

 如何查看索引的使用情况:

索引分类：

mysql事务:

mysql隔离级别: 控制并发事务的可见性和影响范围

mysql中的锁: 

---

java核心：

        1. 面向对象的目标：

                让代码更容易被使用，被理解

                让代码更容易被维护，增强和修改

                面向对象的三大概念：

                        1. 封装 ：将数据和对数据的操作封装在一个单元内部，隐藏数据的具体实现细节，只提供公共方法给外部使用，通过封装可以保证数据的安全性和一致性，并且隐藏实现细节，提高代码的可维护性和可复用性

                            在java中封装可以通过类的定义和访问修饰符实现控制代码的访问权限，并提供get，set方法来访问

                        2. 继承 ：一个类可以继承另一个类的属性和方法，子类可以直接使用父类的属性和方法，无需重新编写相同的代码，实现代码的复用性

                        通过“extends”实现类的继承，子类继承父类非私有成员变量和方法，并且可以通过重写父类的方法实现自己特定的行为，java只支持单继承，但可以通过接口实现多继承

                        3. 多态 ：是指同一类型的对象，在不同情况下表现出不同的行为，具体来说，多态是通过父类或接口的引用指向子类对象，实现对不同子类对象的统一处理

                        多态可以通过继承和接口来实现，当父类或接口引用指向子类对象时，可以根据实际对象的类型调用相应的方法，能够提高代码的灵活性和可扩展性，让程序更容易维护和拓展.

                        多态的示例: 通过父类引用指向不同子类的对象，实现了对不同子类对象的统一处理。(面试题,且举例)

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪的声音");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵的声音");
    }
}


public class Main {
    public static void main(String[] args) {
        Animal[] animals = new Animal[2];
        animals[0] = new Dog();
        animals[1] = new Cat();
        
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

输出的结果: 
    狗发出汪汪的声音
    猫发出喵喵的声音

      总结:   

        1.对象:是一个实例,有状态和行为

        2.类:是一个模板,描述一类对象的行为和状态

        3.方法:方法就是行为,一个类可以有很多方法,逻辑运算,数据修改以及所有动作都是在方法中完成的

        4.实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量决定

常用集合与数据结构: 

单例集合:

                ArrayList: 基于数组结构,查询快增删慢,它是在数组的尾部进行添加和删除数据的,效率上相对于LinkedList集合是比较慢的

                LinkedList: 基于链表结构,查询慢增删快,添加或者删除时只需要改变指针的指向即可,但是它的查询是对整个链表进行遍历

                注: ArrayList的扩容机制: 数组的默认容量是10,在进行扩容时将原数组的数据拷贝一份到新的数组中,并且基于原数组的容量进行扩容1.5倍,这样做会很消耗内存,所以一般我们在使用数组时会给它指定一个容量,避免数组的扩容

双列集合: 

                Map接口: 是最基本的双列集合接口,定义了键值对的基本操作,常见的有

                        HashMap: 基于哈希表实现的键值对集合,通过键的哈希值来快速查找和存储值,提供了快速的插入,删除和查找操作,不保证元素的顺序

                        TreeMap: 基于红黑树实现的键值对集合,按照键的自然顺序或者自定义比较器的顺序进行排序,提供了按照键的顺序遍历元素的功能

                        LinkedHashMap: 基于哈希表和链表实现的键值对集合,按照插入顺序维护元素顺序,提供了按照插入顺序或者访问顺序遍历元素的功能

        HashMap的工作原理:

                1. 存储结构: 他的内部使用数组存储键值对,这个数组被称为哈希桶数组,每一个桶存储一个链表或红黑树,用于解决哈希冲突(不同的键具有相同的哈希值)

                2. 当插入键值对时,hashmap会使用键的哈希函数计算键的哈希值,哈希函数将键映射到哈希桶数组的索引位置

                3. 哈希冲突解决: 如果不同的键具有相同的哈希值,它们将被放置在同一个桶中,形成一个链表或者红黑树,hashmap使用链表或红黑树来解决哈希冲突,提高查询效率

                4. 插入操作: 当插入键值对时,hashmap首先根据键的哈希值计算出对应的桶的索引,如果桶为空则直接将键值对插入到桶中,如果桶中已经存在键值对,则根据键的equals()方法比较键的相等性,如果键已经存在,则更新对应的值;否则,在链表或红黑素的末尾添加新的键值对

                注(面试) : 在进行插入操作时,涉及到链表和红黑树的转换

                        1. 计算哈希值,找到对应的桶索引

                        2. 如果桶为空,直接将键值对插入到桶中

                        3. 如果桶中已经存在键值对,则根据键的equals()方法比较键的相等性

                        4. 如果键已经存在,则更新对应的值

                        5. 如果键不存在,则将心的键值对添加到链表或红黑树的末尾

                        添加新的键值对时,hashmap会检查桶中的元素数量,链表中元素数量阈值默认是8,超过了这个阈值会转为红黑树,能够提供查找,插入和删除操作的效率

                        删除键值对时,红黑树中元素数量阈值默认是6,低于这个阈值则会将红黑树转为链表,以节省内存空间和提高性能

                        链表和红黑树之间的转换只发生在插入和删除操作中

                        (面试)第四点(如果键已经存在,则更新对应的值)会导致hashmap线程不安全: 

                                1.  多线程同时判断某个桶为空,然后尝试将键值对插入桶中,会导致其中一个线程的插入操作被覆盖,导致数据丢失的情况

                                2. 多线程同时判断某个桶中已经存在的键值对,并且需要更新对应的值,在并发情况下,可能会发生竞争条件,导致最终只有一个线程的更新操作生效,其他现线程的更新操作被覆盖,导致数据不一致

                       解决hashmap线程不安全问题的方法:

                                1. 使用线程安全的map实现,比如concurrentHashap,它使用了锁分段技术,能够保证线程安全的同时提高并发性能

                                2. 在多线程环境下,使用显示的同步机制,比如synchronized关键字或者使用lock接口进行同步控制,确保对hashmap的操作是互斥的

                5. 查找操作: 当根据键查找值时,hashmap首先根据键的哈希值计算出对应的桶索引,然后在桶中的链表或者红黑树上进行遍历,根据键的equals()方法比较键的相等性,找到对应的值

                6. 扩容机制: 当HashMap中的键值对数量超过负载因子（默认为0.75）乘以当前桶数组长度时，HashMap会进行扩容操作。扩容会创建一个更大的桶数组，并将所有的键值对重新分配到新的桶中，以减少哈希冲突的概率。(也就是说: 如果桶满了,会创建一个新的桶数组，其长度是原来桶数组长度的两倍并重排)

线程安全的集合: 

     ConcurrentHashMap集合:

         它是java中的一个线程安全的哈希表实现,是对hashmap的一种并发安全的替代方案,与hashmap不同,ConcurrentHashMap支持并发访问,多个线程可以同时读取和修改ConcurrentHashMap的内容,无需额外的同步机制,在多线程的情况下能够提供更好的性能和可伸缩性

        它采用锁分段的机制,将整个哈希表分成多个段(segment),每个段维护一个哈希表,不同的线程可以同时访问和修改不同的段,减少竞争和锁的粒度,提高并发性能,它能够支持任意线程的读操作和默认16个线程的写操作,因为在segment中默认是16个线程但是可以修改

        HashTable集合:

        它实现了map接口,提供了键值对的存储和检索功能,它的特点:

        1. 线程安全: 它使用了同步机制确保多线程环境下的数据一致性和线程安全性,内部使用了synchronized关键之对操作进行同步,确保每个操作都是原子的,同一时间只能被同一个线程执行,在java1..2之后ConcurrentHashMap能够提供比它更好更灵活的性能和操作方式

        2. 键值对存储: 通过键值对的方式存储数据,每个键值对对应一个唯一的值,通过键可以快速检索对应的值

        3. 效率低: 由于它使用了同步机制来确保线程安全,在并发访问较高的情况下,性能可能会受到影响

        4. 不允许null键和null值: 如果尝试存储null键或null值,会抛NullPointerException空指针异常

        CopyOnWriteArrayList集合:

        它是一个线程安全的动态数组,适合频繁的读操作,和较少的写操作场景,它通过在写操作上创建新的数组来实现线程安全,因此读操作不会被阻塞

        CopyOnWriteArraySet集合:

        它是基于CopyOnWriteArrayList实现,保证了集合中元素的唯一性,并提供线程安全的操作

        ConcurrentLinkedQueue队列:

        它是一个线程安全的无界队列,适用于高并发的生产者-消费者场景,它使用无锁算法实现线程安全,并提供了高效的插入和删除操作

        ConcurrentSkipListMap和ConcurrentSkipListSet：

        它们是基于跳表（Skip List）的线程安全的有序集合实现。它们提供了高效的有序访问，并支持并发操作。

数据类型: 

        八大基本数据类型: 

                1. 整数类型: byte,short, int, long

                2. 浮点数类型: float, double

                3. 字符类型: char

                4. 布尔类型: boolean 

        引用数据类型: 

                1. 类class

                2. 接口

                3. 数组

数据结构: 

        线性数据结构: 其中的元素是按照线性顺序排列的,每个元素只有一个前驱和后继,常见的线性数据结构有数组,链表,栈,队列等

        1. 数组: 是一种连续存储的数据结构,通过索引访问,元素具有固定的大小,可以快速访问任意位置的元素,但在插入和删除操作较慢

        2. 链表: 是一种通过节点链接的数据结构,每个节点包含数据和指向下一个节点的指针,链表可以动态的添加和删除,但访问元素需要遍历整个链表

        3. 栈: 是一种后进先出的数据结构,只允许在队尾进行插入和删除操作,常用于函数的调用和表达式求值的场景

        4. 队列: 是一种先进先出的数据结构,只允许在队尾插入元素,在队头删除元素,队列常用于任务调度,消息传递等场景

        非线性数据结构: 其中的元素之间存在多对多的关系,场景的有树和图等

        1. 树(tree): 它是一种层次的数据结构,有节点和边组成,树的每个节点可以有多个节点,根节点没有父节点,常见的树结构有: 二叉树, 二叉搜索树, avl树, 红黑树等

        2. 图(graph): 由节点和边组成的网格结构,节点之间的链接关系可以是任意的,图可以用来表示各种关系和网格关系,常见的图结构有: 有向图和无向图

数据结构的工作原理只要涉及到数据的存储和操作方式,不同的数据结构采用不同的存储方式和操作规则,以满足特定的需求,例如: 数组通过连续的内存空间存储元素,可以通过索引快速访问元素; 链表通过接节点和指针的方式存储元素,可以动态的添加和删除元素; 树通过节点和边的方式存储元素,可以高效的进行搜索和排序等操作

选择合适的数据结构可以提高算法和程序的效率,不同的数据结构适用于不同的场景,根据具体的需求选择合适的数据结构是很重要的

树: 

        二叉树: 每个节点最多有两个字节点,分别称为左子节点和右子节点,二叉树可以是空树也可以是非空树

        二叉搜索树: 是一种特殊的二叉树,他满足:

                1. 左子树上的所有节点的值都小于根节点的值

                2. 右子树上的所有节点的值都大于根节点的值

                3. 左子树和右子树都是二叉搜索树

                特性: 能够在搜索,插入和删除操作上具有较高的效率

        AVL树-平衡二叉搜索树: 通过崽插入和删除操作时进行旋转操作来保持树的平衡,它的性质使得树的高度先对较小,从而提高了搜索和插入等操作的效率

        树的工作原理: 基于节点和边的关系,树的根节点是整个树的起点,通过节点之间的边可以遍历整个树的结构,它的操作可以包括: 插入节点, 删除节点, 搜索节点, 遍历节点等

        存储方式: 常见的有两种

                1. 数组存储: 使用数组存储树的节点,,通过数组的索引关系表示节点之间的父子关系,数组存储方式可以节省内存空间,但在插入和删除节点时需要进行数组的扩容和移动操作,效率较低

                2. 链式存储: 每个节点通过指针或引用指向其字节点,从而形成树的结构,链式存储方式可以动态的添加和删除节点,但需要额外的指针或引用来连接节点,占用的内存空间较大

        根据不同的场景选择合适的树结构,可以提高算法和程序的效率

B树(B-tree): 

        是一种自平衡的搜索树,特点: 多路搜索和平衡性

        它的每个节点可以存储多个键值对,并且节点内的键值对按照键的大小顺序排列

        每个节点还包含指向子节点的指针,子节点的键值范围与父节点的键值范围相对应,通过这种方式,B树可以在磁盘上进行高效的数据检索,减少磁盘IO的次数

B+树: 

        在B树的基础上进行优化的一种树结构,特点:

        将所有的键值对存储在叶子节点上,而非叶子节点只包含键值的范围信息和指向字节点的指针

        叶子节点之间通过指针连接形成一个有序链表,可以支持范围查询和顺序遍历

        B+树的叶子节点的有序链表可以提高范围查询的效率,并且通过减少非叶子节点的大小,可以使得更多的叶子节点存放在内存中,提高磁盘IO的效率

B树和B+树的工作原理和存储方式类似: 主要区别在于叶子节点的结构和使用方式

        他们都采用了多路搜索和平衡性的策略,通过节点的分裂和合并来保持树的平衡

        在插入和删除操作时,B树和B+树会根据平衡性的要求进行相应的调整

        他们的使用范围很广,特别适合用于存储大量数据,支持高效的范围查询和顺序遍历的场景,如数据库索引,文件系统等,其设计的目的是减少磁盘IO的次数,提高数据访问的效率

mysql：

        在5.7版本以后采用了InnoDb存储引擎,给mysql的表提供了事务的处理以及多版本并发控制的事务安全,并且还支持外键约束(父表中的数据更新时,子表中的数据也必须要有相应的改变)

        InnoDb支持ACID(原子性, 一致性, 隔离性, 持久性)事务, 可以确保数据的完整性和一致性,可以使用BEGIN、COMMIT和ROLLBACK语句来开始、提交和回滚事务。

        并发控制: 采用MVCC实现多版本并发控制,mvcc允许读取操作不会阻塞写入操作,并且读取操作之间也不会相互阻塞,提供了并发性能

       行级锁定: 可以在并发访问时对数据进行更细粒度的控制,这意味着多个事务可以同时访问一张表的不同行而不会相互阻塞

        奔溃修复: 提供了崩溃修复的机制,能够在数据库崩溃或异常情况下恢复数据的一致性状态

MVCC:

        是一种并发控制机制,但不是InnoDb的特性, 它是InnoDb中存储引擎实现多版本并发控制的一种技术,在多个事务同时访问数据库时能够保证数据的一致性和并发性

        原理:

                1. 每个事务都有唯一的事务ID或时间戳

                2. 在数据库中,每个数据行都有多个版本,每个版本都有一个时间戳或事务ID

                3. 当一个事务开始时,它创建一个读取视图,该视图包含了事务开始时已经提交的版本信息

                4. 事务只能看到其读取视图中可见的版本,这样可以避免读取未提交的数据和写入冲突

                5. 当一个事务更新数据时,它创建一个新的版本,并将新版本的数据写入磁盘

                6. 其他事务仍然可以读取旧版本的数据,不会收到新版本的影响

                7. 只有在事务提交后,新版本的数据才会对其他事务可见

        特点:

                1. 并发性: mvcc支持多个事务同时读取和修改数据,而不会相互阻塞,提高了并发性能

                2. 读写不冲突: 读操作不会阻塞写操作,写操作不会阻塞读操作,提供了系统的响应速度

                3. 无锁读取: mvcc使用读取视图来控制事务的可见性,避免了对数行的加锁操作,减少锁竞争的情况

                4. 数据一致性: mvcc保证事务的隔离性,事务之间不会相互干扰,保证了数据的一致性

                5. 高度可扩展: mvcc适用于高并发的环境,可以支持大量的并发事务访问数据库,具有良好的可扩展性

                6. 崩溃修复: mvcc通过回滚段(undo log)支持事物的回滚和奔溃修复,保证数据的完整性

mvcc是一种高效的并发控制机制,通过多版本的数据和读取视图来实现事务的隔离和并发访问,提供了良好的并发性能和数据一致性

索引:

        mysql索引是一种数据结构,用于提高数据库查询性能,当索引无法发挥作用时,称为索引失效:

        1. 不使用索引列进行查询: 如果查询条件中不包含索引列,mysql就无法使用索引加速查询

        2. 使用函数或表达式对索引列进行操作: 如果在查询条件中对索引列使用函数或表达式进行操作(例如: 使用函数对列进行计算, 使用like操作符的模糊查询等)

        3. 列类型不匹配: 如果查询天剑中的列类型与索引列的类型(例如:使用字符串进行数值比较)

        4. 数据量过小: 如果表中的数据量非常小,mysql可能会选择全表扫描而不是使用索引

                解释: 使用索引需要额外的存储空间和维护成本,对于小型的表来说,索引的开销可能小队较高,因为需要占用额外的存储空间,并且在插入,更新,删除数据时需要维护索引结构,所以数据量很小的时候全表扫描可能比索引更高效,因为他不需要额外的索引开销

        5. < > , OR, NOT等操作符

SQL优化:         

        1. 最大化的利用索引

        2. 尽可能的避免全表扫描

        3. 较少无效数据的查询

        主要遵循五大原则:

                1. 减少数据访问: 设置合理的字段,启用压缩通过索引访问减少磁盘IO

                2. 返回更少的数据: 只返回需要的字段和数据分页处理,煎炒磁盘IO和网络IO

                3. 减少交互次数: 批量DML操作,函数存储等较少数据连接次数

                4. 减少服务器CPU开销: 经理减少数据库排序操作以及全表扫描,减少CPU内存占用

                5. 利用更多资源: 使用表分区,可以增加并行操作,更大限度利用CPU资源

 如何查看索引的使用情况:

        1. 使用explain关键字,后面跟sql语句,可以查看查询计划,其中包含mysql优化器的决策和索引的使用情况

        1. ID: 查询标识符, 可以用于区分不同的查询操作

        2. select_type: 查询类型, 表示查询的方式,常见的(simple简单查询), (primary主查询)等

        3. table: 查询涉及到的表

        4.  type: 访问表达式,mysql执行查询时使用的访问方法(all全表扫描, index使用索引扫描, range范围查询)等

        5. possible_keys: 可能使用的索引列表,表示查询优化器认为可能使用的索引

        6. key: 实际使用的索引,查询优化器最终选择的索引

        7. key_len: 索引使用的长度,表示索引中使用的字节数

        8. ref: 与索引列进行比较的列或常数值

        9. rows: 估计扫描的行数,表示查询优化器需要扫描的行数

        10. extra: 附加信息,提供一些其他查询的执行计划细节,比例使用了临时表,文件排序等

        通过type列的值判断查询是否进行全表扫描,根据key判断使用使用索引,explain主要是用来分析查询的性能,结合查询结果和数据量对sql语句进行评估和优化

场景题: 

        1. 一条sql最多使用多少索引:

                一个sql能使用多少索引,具体取决于查询条件,,表结构和索引定义. 每个查询条件都可以使用一个索引,但是多个索引的使用可能会增加查询的开销,因此需要权衡索引的数量和查询性能之间的关系

        2. 慢sql如何查看:

                _1. 使用慢查询日志: 在mysql配置文件中启用慢查询日志,并设置阈值,超过阈值的查询将被记录到慢查询日志中,然后可以查看慢查询日志文件,找到执行时间较长的sql语句

                _2. 使用性能分析工具: 使用mysql的性能分析工具或者第三方工具,对查询性能分析,找出执行时间较长的sql语句

索引分类：

        1. 主键索引: 它是一种唯一性索引,用于标识表中的每一行数据,通常是一个自增的数值,在大多数数据库管理系统中,主键索引还会自动创建聚簇索引

        2. 唯一索引: 确保某一列或列组合的值在表中是唯一的,与主键索引不同的是,它允许空值(null),但只允许一个空值,唯一索引能够加速查抄和避免重复数据的插入

        3. 聚簇索引: 决定了表中数据的物理存储顺序,数据行按照索引顺序存储在磁盘上,因此叶子节点包含了实际的数据行,可以直接通过索引进行查询,每个表只能有一个聚簇索引,通常是主键索引,聚簇索引的选择对于查询性能和数据的物理存储非常重要

        4.  非聚簇索引: 它是在数据行之外创建一种独立索引结构,叶子节点包含索引列的值和对应数据行的指针,使用非聚簇索引可以快速定位到满足条件的数据行,一个表可以有多个非聚簇索引

        5. 全文索引: 用于文本类型的列(varchar, text)进行全文搜索,能够加速关键词搜索和匹配,支持高级文本搜索功能,例如模糊匹配,词干提取等,用于处理大量文本数据的搜索场景中

        6. 多列索引: 基于多个列创建的索引,能够加速查询中涉及到多个列的条件过滤和排序操作,多列索引可以根据列的顺序依次进行匹配,也可以同时匹配多个列的值

mysql事务:

        事务是一组数据库操作的逻辑单元,要么全部执行成功,要么全部回滚.它具有四大特性:

        1. 原子性: 在事务中的所有操作要么全部执行成功,要么全部回滚到事务开始前的状态,不存在部分执行成功,部分执行失败的情况,只要有一个操作执行失败,那么整个事务都会被回滚,将所有的修改撤销,回滚到事务开始前的状态

        2. 一致性: 确保事务将数据库从一个一致的状态转换到另一个一致的状态,在事务执行的过程中,数据库的完整性约束不会被破坏(也就是必须满足预定义的规则和约束: 唯一性约束,外键约束,默认值约束等)

        3. 隔离性: 并发执行事务之间应该相互隔离,每个事务的操作应该与其他事务的操作相互独立,保证每个事务执行期间看到的数据是一致的,不会受到其他并发事务的影响

        4. 持久性: 事务一旦提交成功,所做的修改将永久保存在数据库中,即使系统发生故障或重启,也不会丢失事务的提交结果,持久性会将事务的操作记录到事务日志中,这样可以根据日志恢复事务提交的结果

mysql隔离级别: 控制并发事务的可见性和影响范围

        1. 读未提交: 最低的隔离级别, 事务可以读取到其他事务未提交的数据, 会导致脏读问题

        2. 读已提交: 事务只能读取已经提交的数据,避免了脏读问题,但在同一事物中的多次读取会导致读取到不一致的数据,称为不可重复读问题

        3. 可重复读: 保证在同一事物中多次读取相同数据时,读取的结果保持一致.mysql默认的隔离级别就是可重复读,但是这个级别会引发幻读问题(在同一事物中多次查询同一范围的数据,结构集合的行数可能会发生变化)

        4. 串行化: 最高的隔离级别, 事务串行执行,避免脏读,不可重复读和幻读的问题,但是由于串行的特性会导致并发性能下降       

        从隔离级别排序: 读未提交 > 读已提交 > 可重复读 > 串行化

        从并发性能排序: 串行化 > 可重复读 > 读已提交 > 读未提交

在开发中什么情况下使用事务: 

        1. 需要满足mysql事务四大特性时

        2. 一组数据库操作需要作为原子操作执行时

        3. 多个数据库操作之间存在关联关系,需要保证数据的一致性时

        4. 多线程或者请求同时访问共享资源时,需要保证数据的隔离性和一致性时

        5. 当方法执行过程中发生异常时,需要回滚之前的操作时

场景题: 锁释放了,事务没有提交

        对于这个问题需要想到mysql是使用mvcc机制的,它是保证在读取数据时只能看到已提交的数据版本,其他事务在读取数据时将看到该数据的旧版本,而不会看到未提交的修改,如果是在所释放之前,事务没有提交会回滚,其他事务是无法看到该事务所做的修改

        需要注意的是,锁释放了,但事务未提交会对其他事务产生资源占用或导致数据不一致的情况,因此在使用事务时需要合理的管理事务的生命周期,及时提交或回滚,保证数据的一致性和可靠性

mysql中的锁: 

        mysql中的锁主要用于控制并发访问的机制,确保数据的一致性和隔离性

        1. 行级锁: 是粒度最细的锁,可以锁定表中的单个行记录,防止其他事务对同一行进行修改,从而保证并发操作的一致性,InnoDb默认支持行级锁

        2. 表级锁: 针对整个表的锁,能够锁定整个表,阻止其他事务对表的读些操作,粒度较大,会对并发性能产生影响,在并发场景下使用较少

        3. 页级锁: 介于行级锁和表级锁之间的一种锁机制,以数据页为单位进行加锁,一个数据页中有多个行记录,因此页级锁可以锁定多个行,MyIsam存储引擎使用的是页级锁

        4. 共享锁(读锁): 多个事物可以同时持有共享锁,用于读取数据,共享锁之间不会相互阻塞,英文读操作不会对数据产生修改

        5. 排他锁(写锁): 用于对数据进行修改操作,一次只能有一个事务持有排他锁,其他事务无法同事持有共享锁盒排他锁,防止并发修改导致数据不一致性