数据库相关

MyISAM和InnoDB

2.1 两者的对比

1. count运算上的区别： 因为MyISAM缓存有表meta-data（行数等），因此在做COUNT(*)时对于一个结构很好的查询是不需要消耗多少资源的。而对于InnoDB来说，则没有这种缓存。

2. 是否支持事务和崩溃后的安全恢复： MyISAM 强调的是性能，每次查询具有原子性,其执行数度比InnoDB类型更快，但是不提供事务支持。但是InnoDB 提供事务支持事务，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。

3)是否支持外键： MyISAM不支持，而InnoDB支持。

2.2 关于两者的总结

MyISAM更适合读密集的表，而InnoDB更适合写密集的的表。 在数据库做主从分离的情况下，经常选择MyISAM作为主库的存储引擎。

一般来说，如果需要事务支持，并且有较高的并发读取频率(MyISAM的表锁的粒度太大，所以当该表写并发量较高时，要等待的查询就会很多了)，InnoDB是不错的选择。如果你的数据量很大（MyISAM支持压缩特性可以减少磁盘的空间占用），而且不需要支持事务时，MyISAM是最好的选择。

索引

为什么要使用索引？
1.通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
2.可以大大加快数据的检索速度（大大减少的检索的数据库），这也是创建索引的最主要的原因
3.帮助服务器避免排序和临时表
4.将随机IO变为顺序IO
5.可以加速表和表之间的廉连接，特别是在实现数据的参考完整性方面特别有意义

索引这么多优点，为什么不对表中的每一个列创建一个索引呢？
1.当对表中的数据进行增加，删除和修改额时候，索引也要动态的维护，这样就降低了数据的维护速度
2.索引需要占物理空间，除了数据库占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大
3.创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加

索引是如何提高查询速度的？
将无序的数据变成相对有序的数据

说一下使用索引的注意事项？
1.避免where子句中对字段施加函数，这会造成无法命中索引
2.在使用InnoDB时使用与业务无关的自增主键作为主键，即使用逻辑主键而不要使用业务主键
3.将打算加索引列的列设置为NOT NULL ，否则将导致引擎放弃使用索引而全表扫描
4.删除长期未使用的索引，不用的索引的存在会造成不必要的性能耗损MYSQL5.7可以通过查询sys库的chema_unuserd_indexes视图来查询哪些索引从未被使用
5.在使用limit offset查询缓慢时，可以借助索引来提高性能

mysql索引主要使用的两种数据结构？
哈希索引：对于哈希索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单挑记录查询的时候，可以选择哈希索引，查询性能最快，其余带部分场景，建议选择BTree
BTree：mysql的BTree索引使用的是B树种B+Tree。但对于主要的两种存储引擎（MyISAM和InnoDB）的实现方式是不同的。
什么是覆盖索引？
如果一个索引包含（或者说覆盖）所有需要查询的字段的值，我们就称之为覆盖索引。我们知道在InnoDB存储引擎中，如果不是主键索引，叶子节点存储的是主键+列值。最终还是要“回表”，也就是通过主键再查找一次，这样就会比较慢，覆盖索引就是把要查询出的列和索引是对应的，不做回表操作

乐观锁与悲观锁

何谓乐观锁与悲观锁
乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说意中人好于另一种人。

悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁。这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次一个线程使用，其他线程阻塞，用完后再把资源转让给其他线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁，读锁，写锁等都是在操作之前先加上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，想数据库提供的类似于write_condition机制，其实都是提供的 乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景
从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁，即冲突真的很少发生的时候，我们可以省去了锁的开销，加大了系统的整个吞吐量。但是如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，悲观锁一般多写的场景下就比较适用。

乐观锁常见的两种实现方式
1.版本号机制
一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的 version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。
举例：
假设数据库中账号信息表中有一个versin字段，当前值为1，而当前账户余额字段balance为100
a.操作员A此时将其读出version=1，并从其账号余额中扣除50元(100-50)
b.操作员A操作过程中，操作员B也读入此用户信息(version=1)，并从其账号中扣除20（100-20）
c.操作员A完成了修改工作，将数据版本号加1（versison=2），连同账号扣除后余额（balance=50）一起提交至数据库更新，此时由于提交数据库版本大于数据库记录当前版本，数据被更新，数据库记录version=2
d.操作员B完成了操作，也将版本号加1（version=2）试图向数据库提交数据（balance=80）但此时比对数据库记录版本时发现，操作员B提交的数据版本也为2，数据库记录版本也为2，不满足“提交版本必须大于当前版本才能执行更新”的乐观锁策略，因此操作员B的提交被驳回。
这样就避免了操作员B基于version=1的旧数据修改的结果覆盖操作员A的操作结果的可能。

2.CAS算法
即“compare and swap（比较与交换）”是一种有名的无锁算法，无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking synchronized）CAS算法涉及到三个操作数
-需要读写的内存值V
-进行比较的值A
-拟写入的新值B
当且仅当V的值等于A时，CAS通过原子方式用新值B来更新V的值，否则不会执行任何操作（比较好饿替换是一个原子操作）。一般情况下是一个自旋操作，即不断的重试。
关于自旋锁，大家可以看一下这篇文章，非常不错：[面试必备之深入理解自旋锁》](https://blog.csdn.net/qq_34337272/article/details

乐观锁的缺点
1.ABA问题
如果一个变量V初次读取到的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改了吗？很明显不能的，因为在这段时间它的值可能被修改为其他值，然后又改回A，那么CAS操作就会误以为它没被修改过，这个问题被称为ABA问题。
JDK1.5以后的AtomicStampedReference类就提供了此种你能力其中compareAndSet方法就是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的值。
2.循环时间长开销大
自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销，如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它看运气延迟流水线执行指令（de-pipeline），使CPU不会消耗过多的执行资源，延迟时间取决于具体实现的版本，在一些处理器上延迟时间是零，第二他可以避免在退出循环的时候因内存顺序冲突（momory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。
3.只能保证一个共享变量的原子操作
CAS只针对单个共享变量有效，当操作涉及跨多个共享变量时CAS无效，但是从JDK1.5开始，提供了AtomicReference来保证引用对象之间的原子性，你可以把多个变量放在一个对象来进行CAS操作，所以我们可以使用锁或者利用AtomicReference把多个共享变量合并成一个共享变量来操作。

CAS和synchronized的使用场景
简单来说CAS适用于写比较少的情况下（多读场景，冲突一般较少），synchronized适用于写比较多的情况下（多写场景，冲突一般比较多）
对于资源竞争少（线程冲突较轻）的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源，而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此获得更高的性能
对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率比较大，从而浪费更多的cpu资源，效率低于synchronized。

补充：
Java并发编程这个领域synchronized关键字一直都是元老级的角色 ，很久之前很多人都会称它为重量级锁，但是在JavaSE1.6以后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其他各种优化之后变得在某些情况下并不是那么重了，synchronized的底层实现主要依靠Lock-Free的队列，基本思路是自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但是获得了更高的吞吐量，在线程冲突较少的情况下，可以获得和CAS类似的性能，而线程冲突严重的情况下，性能远高于CAS。