JAVA面试圣经

1.把业务的操作写到实体中（这个Account就是一个充血模型）

这么做的好处：
在未来功能增多的情况下，可以知道对于这个账户的所有业务操作都可以从这一个Account实体中了解到。如果使用之前的思想MVC 把对Account的业务操作都写在service或者controller中的话，随着时间的推移，业务的迭代我们程序员不能很清楚的知道对Account类的所有业务操作

2.抽象出只与数据库打交道的repository层

3.防腐层 隔离外部服务

答：不可以

• 乐观锁：乐观锁是一种并发控制策略，它假设事务之间不会产生冲突，因此在读取数据时不会上锁。当更新数据时，会先检查数据是否被其他事务修改过。如果没有修改，则可以直接更新；如果有修改，则需要回滚当前事务或重新尝试。
• 悲观锁：悲观锁是一种并发控制策略，它假设事务之间会产生冲突，因此在读取数据时会上锁，阻止其他事务修改数据。只有当前事务完成后，其他事务才能获取锁并继续操作。
• 自旋锁：自旋锁是一种基于忙等待的锁机制，当线程尝试获取锁时，如果锁已经被其他线程持有，该线程将循环（自旋）等待直到锁被释放。这种锁适用于短暂的临界区域和较少的竞争情况。
• 排他锁：排他锁是一种独占锁，也称为写锁。它允许一个线程独占资源，在该线程释放锁之前，其他线程无法访问该资源。
• 共享锁：共享锁是一种共享访问机制，也称为读锁。它允许多个线程同时访问资源，但不允许写操作。当一个线程持有共享锁时，其他线程也可以获取共享锁，但无法获取排他锁。
• 统一锁：统一锁是一种综合了排他锁和共享锁的锁机制。它具有两种模式：共享模式和排他模式。在共享模式下，多个线程可以同时获得锁并共享资源；在排他模式下，只有一个线程可以获得锁。
• 分段锁：分段锁是一种将数据划分成多个部分，并为每个部分分配一个锁的机制。这样可以提高并发性能，因为不同的线程可以同时访问不同的数据段而不会产生冲突。分段锁常用于数据库等需要处理大量事务的系统中。

1.Class<?> class = Myclass.class();
2.Class<?> class = Class.forName("com.example.Myclass");
3.Class<?> class = obj.getClass();

1.数据结构：

• HashMap底层数据结构是哈希表：适用于快速的增加，删除和查询。他的存储和检索速度通常比TreeMap更快，平均时间复杂度为O(1)。但是不保证元素的有序性。

• TreeMap底层是红黑树：它保证了元素的有序性，一般适用于有序遍历的场景。可以按照键的自然顺序或自定义比较器进行排序。插入、删除和查找操作的时间复杂度为O(log n)。

2.键的唯一性

• HashMap允许键的重复，每个键对应一个值。
• TreeMap要求键唯一，如果插入重复键的元素，后面的元素将会覆盖前面的。

3.内存消耗

• HashMap使用哈希表，它需要额外的内存来存储哈希桶和链表（或红黑树）。相比之下，TreeMap使用红黑树来存储元素，需要更多的内存空间。

链地址法

• 将具有相同哈希值的键值对存储在同一个槽位的链表或红黑树中。这种方式可以高效地处理冲突，保证了HashMap的插入、查找和删除操作的性能。

2个都是线程安全的
但是HashTable是只有一把锁，有十个线程竞争锁的时候，只要有一个线程的到锁，其他九个线程就需要阻塞等待ConcurrentHashMap是分段锁，降低了我们锁冲突的一个概率
ConcurrentHashMap对读操作不加锁，只对写操作进行加锁。

值得注意的是，volatile关键字不能保证原子性。

1. 共享锁（Shared Lock）：允许多个读操作并行执行，但不允许任何写操作，即其他线程不能修改此数据，直到共享锁被释放为止。
2. 排它锁（Exclusive Lock）：允许写操作进行，但不允许其他线程的任何读或写操作，即其他线程不能同时对同一数据进行修改，直到排它锁被释放为止。
3. 行锁（Row Lock）：锁定表中的单行数据，允许读/写操作，其他行不受影响，提高了并发性和效率。
4. 间隙锁（Gap Lock）：​

锁的就是两个值之间的空隙。Mysql默认级别是repeatable-read,有办法解决幻读问题吗？间隙锁在某些情况下可以解决幻读问题。
假设account表里数据如下：

那么间隙就有id为（3,10），（10,20），（20，正无穷）这三个区间，
在Session_1下面执行update account set name='zhuge’where id>8 and id<18;,则其他Session没法在这个范围所包含的所有行记录以及行记录所在的间隙里插入或修改任何数据，即id在（3，20]区间都无法修改数据，注意最后那个20也是包含在内的。
间隙锁是在可重复读隔离级别下才会生效。
​

如：

1. 元数据锁（Metadata Lock）：用于保护数据字典表，以防止操作不当造成损坏。
2. 意向锁（Intention Lock）：表示事务正在获取数据对象的共享锁或排它锁，并提高了锁定效率。
3. 记录锁（Record Lock）：用于对表中某一行/记录进行锁定，防止其他线程对该行数据进行修改操作。
4. 插入意向锁（Insert Intention Lock）：在一次事务中，先对索引上相应的间隙置上意向锁，再在该间隙内进行插入操作。
5. 自适应锁（Adaptive Locking）：根据访问数据的情况调整锁定策略，提高并发性能。

1、读未提交内容（read-uncommitted）

在该隔离级别中，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。

该隔离级别会出现的问题是：脏读(Dirty Read)，即读取到了未提交的数据。

2、读取提交内容（read-committed）

这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。

该隔离级别会出现的问题是：不可重复读(Nonrepeatable Read)，即不可重复读意味着我们在同一个事务中执行完全相同的select语句时可能看到不一样的结果。

导致这种情况的原因可能有：

1)、有一个交叉的事务有新的commit，导致了数据的改变;

2)、一个数据库被多个实例操作时,同一事务的其他实例在该实例处理其间可能会有新的commit

3、可重复读（repeatable-read）

这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。

不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。

简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。

InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。

4、可串行化（serializable）

这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

在这个级别，可能导致大量的超时现象和锁竞争。

1.null值，<>或!=，%a%, 索引列上的sum()这种计算 会导致不走索引要尽量避免
2最左前缀匹配原则，Mysql会一直向右匹配直到遇到范围查询（>、<、between、like）就停止匹配，
比如a=3 and b=4 and c>5 and d=6如果建立（a，b，c，d）顺序的索引，d是用不到索引的，如果建立（a，b，d，c）的索引则都可以用到，a，b，d的顺序可以任意调整。
=和in可以乱序，比如a=1 and b=2 and c=3建立（a，b，c）索引可以任意顺序，mysql的查询优化器会帮你优化成索引可以识别的形式
3.索引字段最好小而且唯一，避免select * 的情况

在innodb中主键采用的就是聚簇索引，并且一个表只有一个聚簇索引
聚簇索引（主键索引）：就是b+树的叶子节点存放的数据是表的所有的数据
辅助键索引：就是我们一般数据库中添加的索引，它的叶子节点存储的是索引的列值和主键id
所以 如果走辅助键索引的话，它要查询2次，直接走主键索引的话就只需要查询一次即可

聚簇索引的优点
1.当你需要取出一定范围内的数据时，用聚簇索引也比用非聚族索引好。
2.当通过聚族索引查找目标数据时理论上比非聚族索引要快，因为非聚族索引定位到对应主键时还要多一次目
标记录寻址,即多一次I/O。
3.使用覆盖索引扫描的查询可以直接使用页节点中的主键值。
聚簇索引的缺点
1插入速度严重依赖于插入顺序。
2更新主键的代价很高，因为将会导致被更新的行移动。
3.二级索引访问需要两次索引查找，第一次找到主键值，第二次根据主键值找到行数据。

区别：cookie是存在浏览器端的，session是存在服务器端的
用户登录的时候通过cookie将用户的认证信息（账号密码）发送给服务器，服务器通过对比数据库中用户的账号密码，将用户的信息存在session中，并把sessionId通过cookie传给浏览器。下次用户登录的时候，通过这个sessionId来查看用户是否登录

基于session的

基于Token的

sleep()是静态方法，用于将线程睡眠，将执行状态变成显示阻塞状态，并且不会释放锁
wait()需要在synchronized{}代码块中使用，他会释放锁，并且只有在notify()，notifyall()方法后才可以停止阻塞去争夺锁

• corePoolSize：核心线程数，也是线程池中常驻的线程数，线程池初始化时默认是没有线程的，当任务来临时才开始创建线程去执行任务

• maximumPoolSize：最大线程数，在核心线程数的基础上可能会额外增加一些非核心线程，需要注意的是只有当workQueue队列填满时才会创建多于corePoolSize的线程(线程池总线程数不超过maxPoolSize)

• keepAliveTime：非核心线程的空闲时间超过keepAliveTime就会被自动终止回收掉，注意当corePoolSize=maxPoolSize时，keepAliveTime参数也就不起作用了(因为不存在非核心线程)；

• unit：keepAliveTime的时间单位

• workQueue：用于保存任务的队列，可以为无界、有界、同步移交三种队列类型之一，当池子里的工作线程数大于corePoolSize时，这时新进来的任务会被放到队列中

• threadFactory：创建线程的工厂类，默认使用Executors.defaultThreadFactory()，也可以使用guava库的ThreadFactoryBuilder来创建

• handler：线程池无法继续接收任务(队列已满且线程数达到maximunPoolSize)时的饱和策略，取值有AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy、DiscardPolicy

tomcat线程池如果当前运行的线程，少于corePoolSize，则创建一个新的线程来执行任务。如果线程数大于 corePoolSize了，Tomcat 的线程不会直接把线程加入到无界的阻塞队列中，而是去判断submittedCount（已经提交线程数）是否等于 maximumPoolSize。如果等于，表示线程池已经满负荷运行，不能再创建线程了，直接把线程提交到队列，如果不等于，则需要判断，是否有空闲线程可以消费

• 通过volatile关键字
• 通过AtomicBoolean类型 下面的代码包括了AtomicBoolean和volatile

public class DeadLock {
   static volatile  boolean isStop = false;
   static AtomicBoolean atomicBoolean = new AtomicBoolean(false);  //原子布尔型
    public static void main(String[] args) throws Exception{

    new Thread(()->{
        while (true){
            if(isStop /*atomicBoolean.get()*/){
                System.out.println("线程1线程停止了");
                break;
            }
            System.out.println("线程1执行中---");
        }
    }).start();


    TimeUnit.SECONDS.sleep(1);

    new Thread(()->{  // 通过线程2修改可见的isStop来对线程1进行中断
        isStop=true;
        // atomicBoolean.set(true);
    }).start();
    }
}

• 通过Thread类自带的中断api实现

public class DeadLock {
    public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(()->{
        while (true){
            if(Thread.currentThread().isInterrupted()){
                System.out.println("线程1线程停止了");
                break;
            }
            System.out.println("线程1执行中---");
        }
    });
    t1.start();



    TimeUnit.SECONDS.sleep(1);

    new Thread(()->{  
        t1.interrupt();
    }).start();
    }
}

• 答：不是

事例1:

public class DeadLock {
    public static void main(String[] args) throws Exception{
    Thread t1 = new Thread(()->{
            for (int i = 0; i < 300; i++) {
                System.out.println("------"+i);
            }
    });
    t1.start();
    
    TimeUnit.MILLISECONDS.sleep(1);
        System.out.println("线程1是否被打断情况"+t1.isInterrupted()); //false


    new Thread(()->{  // 通过线程2修改可见的isStop来对线程1进行中断
        t1.interrupt(); // true
        System.out.println("线程1的是否被打断情况"+t1.isInterrupted()); //true
    }).start();

        TimeUnit.MILLISECONDS.sleep(2000);
        System.out.println("线程1是否被打断情况"+t1.isInterrupted()); //false    中断不活动的线程不会产生任何影响

    }

事例2:

public class DeadLock {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("程序运行中");
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("线程t1被中断了，中断标识位:" + Thread.currentThread().isInterrupted());
                    break;
                }

                try {
                    Thread.sleep(200); //sleep方法会在别的线程中断当前线程的时候报出InterruptedException，并将中断标识清空置为false。就会导致死循环
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();  //这行代码是为了防止线程报错 而没有修改中断标识位的值为true  而造成死循环
                    e.printStackTrace();
                }
            }

        });
        t1.start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {  // 通过线程2修改可见的isStop来对线程1进行中断
            t1.interrupt(); // true
        }).start();
    }
}

@TOC

它的作用是：1.用来判断线程是否被中断2.将当前线程的中断状态清零并重新设为false，清除当前中断状态

代码演示

public class DeadLock {
    public static void main(String[] args) throws Exception {

        System.out.println(Thread.currentThread().getName()+"线程的中断状态:"+Thread.interrupted());  //false
        System.out.println(Thread.currentThread().getName()+"线程的中断状态:"+Thread.interrupted());  //false

        Thread.currentThread().interrupt();

        System.out.println(Thread.currentThread().getName()+"线程的中断状态:"+Thread.interrupted());  //true
        System.out.println(Thread.currentThread().getName()+"线程的中断状态:"+Thread.interrupted());  //false

}

}

Thread.interrupted()方法和isInterrupted()方法底层都调用了isInterrupted()方法（见p2，而是否清除中断状态取决于入参是否为true）

根据根可达性算法 如过从根节点出发，一直查询相关的引用对象，没有被引用的对象就直接被垃圾回收

在Java语言中，可以作为GCRoots的对象包括下面几种：

(1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。

(2). 方法区中的类静态属性引用的对象。

(3). 方法区中常量引用的对象。

(4). 本地方法栈中JNI(Native方法)引用的对象。

Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

在加载，查找一个.class文件的时候首先会把这个任务委派给父加载器去加载，如果父加载失败，就再给下一级去加载。
这么做的好处：
1、避免类重复加载
2、安全性 如果你自己写了一个java.lang.String 就无法覆盖类库中的类

1.服务限流
2.使用消息队列
3.服务降级
4.热点数据，缓存在缓存中间件中（问卷信息）
5.读写分离
6.负载均衡

代码层面：
1.通过canal 异步同步数据
2.通过延时双删（先删除缓存，更新数据库，休眠一段时间，删除缓存）

字符串(string) 缓存数据：将经常使用的数据存储在 Redis 中，可以提高访问速度。计数器：可以使用 Redis 的自增命令实现计数器功能。分布式锁：可以使用 Redis 的 SETNX 命令实现分布式锁。
哈希(hash) 存储对象：可以将对象的各个属性存储在哈希中，方便查询和修改。 用户对象
列表(list) 消息队列：可以使用列表实现简单的消息队列。
集合(set) 去重：可以使用集合存储重复的数据，然后使用 SREM 命令删除重复数据。标签系统：可以使用集合存储文章的标签，然后根据标签查询相关文章。 推荐系统：可以使用集合存储用户的喜好，然后根据相似度推荐相关内容。
有序集合(zset) ：排行榜：可以使用有序集合存储用户的得分，然后根据得分排序。数据分析：可以使用有序集合存储数据的分值，然后根据分值查询相关数据。推荐系统：可以使用有序集合存储用户的喜好和权重，然后根据相似度推荐相关内容。

1.重载是定义相同的方法名，参数不同；重写是子类重写父类的方法。

2.重载是编译时多态，重写是运行时多态

3.重载的入参和反参可以改变，重写的入参和反参要和父类保持一致

4.重载是在一个类中的，重写是在父类和子类中的

5.重载对访问的修饰没有要求，重写访问修饰符的限制一定要大于被重写方法的访问修饰符。（父类是public 子类可以是public和protected， 父类是protected子类重写可以用public或protected，但不可以使用private）

1.配置主从复制：建立主数据库（写库），建立从数据库（读库），并让读库去同步主库的binlog日志与主库数据保持一致

2.独写切分：在应用中明确读操作和写操作的分离。根据业务需求将读操作发送到从数据库，写操作发送到主数据库

1.消息持久化：消息在发送后即使在系统故障或重启后也能有所保留

2.ack机制：生产者把消息推送给MQ之后，要求MQ返回一个确认收到消息的信息给生产者，表示消息已经成功

3.事务机制

4.消息重试：消费者处理消息报错，MQ系统可以进行消息重试

5.高可用性和冗余：通过将MQ系统部署再多个节点上，实现数据的冗余存储和高可用性，及时某个节点发生故障，消息依然可以在其他节点进行处理

6.监控和报警

1.预加载缓存：系统高峰或者发布生产上线的时候，提前将热点数据存储到缓存中

2.缓存击穿：redis的热点数据突然失效，大量请求直接访问数据库，数据库压力剧增
解决方案：
设置合理的缓存过期时间：将热点数据的过期时间设置为较长的时间，避免过快地过期。
使用互斥锁（Mutex Lock）：当一个请求发现缓存失效时，可以尝试获取一个互斥锁，然后再从后端存储系统中加载数据并更新缓存。其他请求在这个过程中会等待，并共享加载后的数据。
预先加载热点数据：在系统启动时或非高峰期，可以预先加载一些热点数据到缓存中，避免在真正需要时才去加载。

3.缓存雪崩：redis大量缓存突然失效，导致大量查询需要访问数据库，数据库压力剧增
解决方案：
设置合理的缓存过期时间：将缓存的过期时间分散开，避免大量缓存同时失效。
引入随机过期时间：给缓存设置一个随机的过期时间，使得缓存不会同时失效。
使用缓存高可用方案：通过使用缓存集群、主从复制、哨兵或集群模式等方式，保证缓存系统的高可用性，避免单点故障导致的缓存失效问题。
数据预加载和异步更新：在缓存失效前，提前异步加载数据或者使用热点数据预加载策略，保证缓存的及时更新。
限流和熔断机制：在缓存失效时，对请求进行限流或熔断，避免请求直接访问后端存储系统的压力过大。

4.缓存穿透：整一个系统redis找不到数据，数据库也找不到数据，（恶意请求或无效数据请求绕过缓存直接访问后端存储系统）导致数据库压力剧增。
解决方案：
输入合法性验证：在接收到请求前，对请求参数进行校验，例如验证请求参数的格式、长度等。如果请求参数不合法，可以直接拒绝访问，避免查询无效数据。
布隆过滤器（Bloom Filter）：使用布隆过滤器来过滤掉不存在于后端存储系统中的数据请求。布隆过滤器是一种空间效率很高的概率型数据结构，可以快速判断一个元素是否存在于集合中。