2023 面试总结

1、ACID 是什么 一致性和原子性的区别。
A(atomic)原子性
C(consistency) 一致性
I(isolation)隔离性
D(durability）持久性
一致性是基础，也是最终目的，其他三个特性都是保障一致性运行的。
原子性是保证一个事务运行是成功的，而一致性是保证多个事务运行是符合正常预期的，符合正常逻辑的。
2.sql优化 怎么优化的？

1. 避免使用select
2. 用union all代替union
3. 小表驱动大表
   （1）这个需求中，order表有10000条数据，而user表有100条数据。order表是大表，user表是小表。如果order表在左边，则用in关键字性能更好。
   in 适用于左边大表，右边小表。

    select * from order
where user_id in (select id from user where status=1)

exists 适用于左边小表，右边大表。

    select * from order
where exists (select 1 from user where order.user_id = user.id and status=1)

4. 批量操作
   （1）众所周知，我们在代码中，每次远程请求数据库，是会消耗一定性能的。而如果我们的代码需要请求多次数据库，才能完成本次业务功能，势必会消耗更多的性能。
   所以批量插入 使用orderMapper.insertBatch(list): 批量插入比较好，而不是for循环遍历单个插入。 这样只需要远程请求一次数据库，sql性能会得到提升，数据量越多，提升越大。
   （2）但需要注意的是，不建议一次批量操作太多的数据，如果数据太多数据库响应也会很慢。批量操作需要把握一个度，建议每批数据尽量控制在500以内。如果数据多于500，则分多批次处理。
5. 多用limit
   此外，在删除或者修改数据时，为了防止误操作，导致删除或修改了不相干的数据，也可以在sql语句最后加上limit。

update order set status=0,edit_time=now(3) 
where id>=100 and id<200 limit 100;

6，where 不要用表达式，函数是操作
7，尽量使用union 不要使用or
举例
采用 OR 语句：
SELECT * FROM a, b WHERE a.p = b.q or a.x = b.y;
采用 UNION 语句，返回的结果同上面的一样，但是速度要快些：
SELECT * FROM a, b WHERE a.p = b.q
UNION
SELECT * FROM a, b WHERE a.x = b.y
NION 是用一个明确的值到索引中查找，目标非常明确，OR 需要对比两个值，目标相对要模糊一些，所以 OR 在恍惚中落后了
8，连续字段查询 between尽量用 不用in和not in。
3,文件传输 10g的文件怎么设计的。
a、方案一，常规步骤

将需要上传的文件按照一定的分割规则，分割成相同大小的数据块；

初始化一个分片上传任务，返回本次分片上传唯一标识；

按照一定的策略（串行或并行）发送各个分片数据块；

b、方案二、本文实现的步骤

前端（客户端）需要根据固定大小对文件进行分片，请求后端（服务端）时要带上分片序号和大小

服务端创建conf文件用来记录分块位置，conf文件长度为总分片数，每上传一个分块即向conf文件中写入一个127，那么没上传的位置就是默认的0,已上传的就是Byte.MAX_VALUE 127（这步是实现断点续传和秒传的核心步骤）

服务器按照请求数据中给的分片序号和每片分块大小（分片大小是固定且一样的）算出开始位置，与读取到的文件片段数据，写入文件

发送完成后，服务端根据判断数据上传是否完整，如果完整，则进行数据块合成得到原始文件。

4 static synchronized 能保证线程安全吗 为什么
synchronized是实例锁，对类的当前实例进行加锁，防止其他线程同时访问该实例的所有synchronized块。
static synchronized是类锁，控制类的所有实例的并发访问，限制多线程中该类的所有实例同时访问JVM中该类所对应的代码块。
5， 熟悉设计者模式吗 观察者模式的优缺点
单例模式 ，观察者模式 ，适配器模式

优点：

1、观察者和被观察者之间建立了一个抽象的耦合。

2、观察者模式支持广播通信。
缺点：

1、观察者之间有过多的细节依赖、提高时间消耗及程序的复杂度。

2、使用要得当，要避免循环调用。

Atomic 乐观锁。

2023/6/26

一,kafka 的淘汰机制 zookper的作用
1、 基于时间，默认配置是168小时（7天）。
2、 基于大小，默认配置是1073741824。
Zookeeper： kafka集群依赖zookeper来保存集群的元信息，保证系统的可用性

redis的淘汰机制策略
四种算法 ifu iru ttl radom
ifu最少的使用的删除，根据次数
ilu最少使用的删除，根据时间。
ttl，快过期的删除，
radom，过期的随机删除。
八种策略
（1）volatile-lru，针对设置了过期时间的key，使用lru算法进行淘汰。
（2）allkeys-lru，针对所有key使用lru算法进行淘汰。
（3）volatile-lfu，针对设置了过期时间的key，使用lfu算法进行淘汰。
（4）allkeys-lfu，针对所有key使用lfu算法进行淘汰。
（5）volatile-random，从所有设置了过期时间的key中使用随机淘汰的方式进行淘汰。
（6）allkeys-random，针对所有的key使用随机淘汰机制进行淘汰。
（7）volatile-ttl，删除生存时间最近的一个键。
（8）noeviction(默认)，不删除键，值返回错误。
三 解释下 主从模式 哨兵模式

四 ，MySQL 常用的函数。
创建索引，修改索引 CREATE INDEX、ALTER TABLE和EXPLAIN

拼接函数concat 查询字节长度length 转化大写upper 转换小写lower substr 截取函数
substr substring区别 比如substr （1，3），substring （1，3）
substr是从第1位截取开始截取三位 substring 第1位截取 再从开始截取3位，是1~3的差值。
五，存储 引擎inodb mylsam 优缺点。

InnoDB存储引擎:用于事务处理应用程序，具有众多特性，包括ACID事务支持、支持外键。同时支持崩溃修复能力和并发控制。如果对事务的完整性要求比较高，要求实现并发控制，那选择InnoDB存储引擎有很大的优势。需要频繁地进行更新、删除操作的数据库，也可以选择InnoDB存储引擎。因为，该类存储引擎可以实现事务的提交(Commit）和回滚(Rollback)。

MyISAM存储引擎:管理非事务表，它提供高速存储和检索，以及全文搜索能力。MyISAM存储引擎插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出记录，那么选择MyISAM存储引擎能实现处理的高效率。如果应用的完整性、并发性要求很低，也可以选择MyISAM存储引擎。

MEMORY存储引擎:MEMORY存储引擎提供“内存中”表，MEMORY存储引擎的所有数据都在内存中，数据的处理速度快，但安全性不高。如果需要很快的读写速度，对数据的安全性要求较低，可以选择MEMORY存储引擎。MEMORY存储引擎对表的大小有要求，不能建太大的表。所以，这类数据库只使用相对较小的数据库表。
以上存储引擎的选择建议是根据不同存储引擎的特点提出的，并不是绝对的。实际应用中还需要根据各自的实际情况进行分析。

2023 07
一、redis跟数据库的数据同步问题
在修改数据的时候，通常面临着双写的问题，也就是redis中要更新数据，数据库中也要更新数据，对于这个问题redis、数据库的数据同步方案有四种：

1、先更新Redis缓存，再更新数据库
2、先更新数据库，再更新Redis缓存
3、先删除Redis中的缓存，再更新数据库
4、先更新数据库，在删除Redis缓存

二、关系型数据库 有哪些。
常用的mysql ，Oracle db2；
MySQL对复杂SQL支持较弱，在运行时可能会存在性能问题；DB2支持各种复杂SQL，多种jion方式。
并发处理，mssql均优于db2。
MySQL默认使用大小写敏感的数据库名、表名和列名；而DB2数据库对大小写不敏感。
Oracle 大型数据库，mysql小型数据库，但可以分库分表。
三、索引什么时候会失效
使用不规范的时候，
1、like查询以“%”开头；
2、or语句前后没有同时使用索引；
3、组合索引中不是使用第一列索引；
4、在索引列上使用“IS NULL”或“IS NOT NULL”操作；
5、在索引字段上使用“not”，“<>”，“!=”。
四、常用的锁。默认的锁
悲观锁synchronized，lock锁 包含ReentrantLock、ReentrantReadWriteLock。
atomic 乐观锁 是基于cas机制实现的。
五、Java代码优化
1、不要在循环中使用try…catch…，应该把其放在最外层
2、如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度
3、尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销
4、不要将数组声明为public static final
因为这毫无意义，这样只是定义了引用为static final，数组的内容还是可以随意改变的，将数组声明为public更是一个安全漏洞，这意味着这个数组可以被外部类所改变
5、尽量在合适的场合使用单例

使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：

（1）控制资源的使用，通过线程同步来控制资源的并发访问

（2）控制实例的产生，以达到节约资源的目的

（3）控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

六、Java单例模式
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
2、避免对资源的多重占用（比如写文件操作）。

缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

单例也分为 懒汉模式(线程不安全)和饿汉模式(线程安全)

区别就是:

懒汉模式第一次调用的时候才创建对象

而饿汉模式 是在类加载的时候就创建了对象，在项目启动时就会加载。

解决懒汉模式线程不安全的最佳方式 就是双重校验锁

public class SingleInstance {
    //必须有volatile修饰（防止指令重排序）
    private volatile static SingleInstance instance;
    //构造函数必须私有（防止外部通过构造方法创建对象）
    private SingleInstance() {
    }
  
    public static SingleInstance getInstance() {
        //第一个判空（如果是空，就不必再进入同步代码块了，提升效率）
        if (instance == null) {
        	//这里加锁，是为了防止多线程的情况下出现实例化多个对象的情况
            synchronized (SingleInstance.class) {
                //第二个判空（如果是空，就实例化对象）
                if (instance == null) {
                    //新建实例
                    instance = new SingleInstance();
                }
            }
        }
        return instance;
    }
}