2023-04-19_面试题复盘笔记（230）_两条更新语句更新同一条记录的不同字段,加的是什么锁 ?

一、腾讯软件后台开发

1.java中锁有哪些类型？

Java中有几种类型的锁：
1.synchronized关键字锁：用于同步访问共享资源，保证线程安全。
2.ReentrantLock类锁：提供了比synchronized更加灵活和可扩展的同步机制。
3.ReadWriteLock读写锁：允许多个线程同时读取一个共享资源，但只允许一个线程写入。
4.StampedLock类锁：提供了一种乐观锁的实现方式，在读请求较多的情况下性能更好。
5.Semaphore信号量锁：一种计数器机制，限制同时访问某个资源的线程数量。

2.Java中如何创建对象

java中提供了以下四种创建对象的方式:
1.new创建新对象
2.通过反射机制
3.采用clone机制
4.通过序列化机制

3.static关键字的作用，static修饰的字段什么时候初始化

static关键字通常用于修饰变量或函数，具有不同的作用。当static修饰一个变量时，它的含义是静态变量，它被存储在数据区，只会在程序启动时被初始化一次，并保持其值直到程序结束。而当static修饰一个函数时，它的含义是静态函数，这种函数只能在声明它的文件中被调用，不能被其他文件调用。
关于static修饰的字段，它们有不同的初始化时机，具体取决于它们的使用方式。如果一个static字段是直接初始化的，那么它会在程序启动时被初始化；如果它没有被显式初始化，那么它会被默认初始化为0，同样会在程序启动时初始化。值得注意的是，在某些情况下，static字段的初始化可能会比程序启动更早，这主要是由于编译器优化的结果。

4.Java的内存模型，内存持续上涨如何排查

Java的内存模型定义了Java程序在运行时内存的组织方式和访问规则。如果在程序运行过程中内存持续上涨，可能会导致性能降低或者崩溃。为了排查这种情况，可以采取以下几个步骤：
1.使用Java内置的诊断工具来监测内存使用情况，如jstat、jmap、jps等，可以查看Java进程的GC情况、堆内存使用情况、线程情况等。
2.使用Java Profiler工具，例如Java VisualVM、jProfiler、YourKit等，可以深入了解Java应用程序的实时内存使用情况、瓶颈所在等信息，帮助发现内存泄漏等问题。
3.检查Java应用程序的代码，尤其是静态成员变量、全局变量等是否被正确的初始化、使用，是否存在引用未释放、内存泄漏等问题。
4.调整Java应用程序的JVM参数，如设置合适的堆内存大小、调整GC策略等，可以改善系统的内存使用。
总之，要排查Java程序内存持续上涨的问题需要综合运用各种工具和方法，深入了解程序的实际情况，并作出相应的优化和调整。

5.Java中有哪些map

在Java中，常用的Map有以下几种：
1.HashMap：无序的Map实现，基于哈希表实现，允许key和value为null；
2.TreeMap：有序的Map实现，基于红黑树实现，不允许key为null，value可为null；
3.LinkedHashMap：有序的Map实现，继承于HashMap，在HashMap的基础上维护了一个双向链表，可以按照插入顺序或者访问顺序存储元素，允许key和value为null；
4.ConcurrentHashMap：线程安全的Map实现，基于分段锁实现并发读写，允许key和value为null；
5.WeakHashMap：弱引用的Map实现，当key没有其他引用时，会被GC回收掉，一般用来解决内存泄漏问题；
6.IdentityHashMap：使用==检测相等性的Map实现，而不是使用equals方法，key可以为任意对象，不允许key和value为null。

6.sychronized如何使用，sychronized可以锁空对象吗

Synchronized 是 Java 中用于同步访问共享资源的关键字，可以用来保证多个线程访问同一个对象时的同步互斥。它可以锁定对象或者类，来避免多个线程同时访问，在同步代码块中的代码只有在获得了锁之后才能运行。
如果 Synchronized 锁的是空对象，不会有任何效果，因为没有任何线程正在使用该对象，所以也就无需同步。因此，Synchronized 无法锁定空对象。建议在使用 Synchronized 关键字时，应该选择一个有实际应用价值的对象来作为锁对象，能够唯一标识出哪一段代码需要被同步。

7.从输入URL 到页面展示到底发生了什么？

整个过程可以分为以下几个步骤：
1.输入URL：当您在浏览器地址栏中输入URL时，浏览器会将该URL发送到域名系统（DNS），通过域名系统将URL转化为IP地址。
2.发送HTTP请求：浏览器根据URL发起HTTP请求，请求访问Web服务器的特定资源。
3.服务器响应：当Web服务器接收到请求时，它将处理请求并返回所请求的资源。
4.浏览器渲染：浏览器收到服务器响应后，它将解析HTML源代码，并根据CSS样式表和JavaScript代码来渲染页面。
5.页面展示：最终，浏览器将HTML、CSS和JavaScript代码解析完毕后，它会在屏幕上展示出页面内容。
以上就是从输入URL到页面展示的整个过程。

8.DNS是如何解析的？DNS可以解析端口吗？

DNS解析URL时，它会首先查询域名对应的IP地址，然后通过路由器等网络设备将网络请求发送至该IP地址，实现对URL的访问。 DNS只能解析IP地址，无法解析特定端口，因此在访问URL时需要在请求中指定该URL的端口号。

9.建立TCP连接，Socket在TCP握手哪个阶段可以拿到连接

Socket 在 TCP 握手的第三次握手阶段可以拿到连接。在第一次握手，客户端发送 SYN 给服务器端；在第二次握手，服务器端发送 SYN ACK 给客户端；在第三次握手，客户端发送 ACK 给服务器端，同时建立连接。在第三次握手阶段中，客户端和服务器端都拿到了该连接的 Socket。

10.socket编程时使用了多线程吗，如果浏览器没有显示页面有哪些原因

socket编程使用了多线程，实际上这取决于具体的实现方式。在有些情况下，可以使用多线程来处理与客户端的通信请求；而有些情况下，则可以使用单线程加事件循环的方式来完成同样的任务。
至于浏览器没有显示页面的原因可能有很多，比如网络连接问题、服务器故障、客户端浏览器配置问题等等。需要具体分析具体情况才能够定位问题。

11.TIME_WAIT是如何产生的？为什么要TIME_WAIT？

TIME_WAIT是在TCP连接关闭时，连接的一端会进入一个等待状态，称为TIME_WAIT状态。这个状态是用来确保双方都确认了连接的正常关闭，避免在之后出现重复连接或错误连接。
在TCP连接关闭时，一般是由主动方发起FIN来结束连接，而被动方会回复ACK确认关闭。如果被动方发现在ACK发送后还有未收到的数据包，它会重新发送ACK，然后保持TCP连接处于TIME_WAIT状态，等待最后一个FIN的发送和确认。这样，TIME_WAIT就可以在确定连接已完成时，保护对端避免建立错误的连接。
另外，TIME_WAIT还可以保证TCP连接的可靠性。因为在TIME_WAIT期间，它会为任意意外扔掉的ACK提供容错处理，以确保数据传输的完整性和正确性。

13.MYSQL事务隔离级别，Innodb使用的是哪种

MySQL事务隔离级别包括读未提交（read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（serializable），InnoDB默认使用的是可重复读（repeatable read）隔离级别。

14.Innodb中的锁类型

InnoDB中有两种类型的锁：共享锁和排他锁。共享锁（Shared Locks）也称为读锁，当事务需要读取数据时，可以给数据加上共享锁。多个事务可以同时持有同一份数据的共享锁，但是如果一个事务持有了共享锁，则其他事务就不能给该数据加上排他锁。排他锁（Exclusive Locks）也称为写锁，当事务需要修改数据时，需要给数据加上排他锁，其他事务就不能给该数据加上任何类型的锁。只有当持有共享锁的事务释放锁之后，才能给该数据加上排他锁。

15.脏读幻读区别

脏读和幻读都是数据库中的一种问题，但它们的区别在于锁的范围不同。脏读是指在一个事务中读取到另一个未提交事务的数据，而幻读是指在一个事务中多次读取同一个条件的记录，但由于另一个事务插入了符合该条件的记录，导致前一个事务中读取到了更多的记录。简而言之，脏读是读到了脏数据，而幻读则是读到了幻影数据。

16.一条Update语句没有带where条件，加的是什么锁

在执行没有where条件的update语句时，会锁定整张表，即表级锁。这会导致其他用户无法修改该表中的任何记录，直到当前事务完成。因此，在使用update语句时，一定要谨慎地使用where条件，确保只更新需要更新的记录，避免对整张表进行锁定。

17.带了where条件没有命中索引，加的是什么锁

这条Update语句会加上表级锁（table lock）。因为在未命中索引时，需要扫描整张表，这会涉及到多个行的读取和写入操作，为了保证数据的一致性，MySQL会对整张表进行加锁以进行排它性控制。

18.两条更新语句更新同一条记录，加的是什么锁

当两条更新语句同时对同一行记录进行更新时，会发生竞态条件（race condition），这可能导致数据一致性问题。为了避免这种情况，数据库管理系统通常会使用行级锁，其中一种是排他锁（exclusive lock）。排他锁可以确保同一时刻只有一个事务能够对该行进行更新，其他事务必须等待该事务释放锁后才能继续操作。因此，当两条更新语句更新同一条记录时，它们会加上排他锁。

19.两条更新语句更新同一条记录的不同字段，加的是什么锁

这取决于具体的数据库管理系统和事务隔离级别。一般情况下，如果两条更新语句更新同一条记录的不同字段，并且使用了默认的事务隔离级别，那么会使用行级别的写锁来保证数据的一致性。但是如果使用了比较严格的事务隔离级别，并且设置了更高级别的锁定机制，可能会使用表级别或者页面级别的锁。

20.Redis

Redis是一种开源的、支持网络、基于内存、键值对存储数据库管理系统，可以用作数据库、缓存、消息中间件等多种用途。它支持多种数据结构的存储，包括字符串、哈希、列表、集合等。Redis的出色性能得益于它将所有数据都存储在内存中，并使用异步I/O和多路复用技术来减少网络延迟和提高吞吐量。

21.操作系统死锁是如何发生的？

操作系统死锁是指在并发执行的进程中，彼此占用对方所需资源而无法继续执行的一种状态。它通常发生在系统中存在多个并发进程，这些进程都需要访问系统中的共享资源，但是由于没有得到满足所需的资源，进程一直等待而不能执行下去，最终导致整个系统陷入停滞。
操作系统死锁的发生必须同时满足以下四个条件，也被称为死锁的必要条件，包括资源互斥、占有和等待、不可抢占和循环等待。
1.资源互斥：一个资源同时只能被一个进程使用，如果有一个进程占用了某个资源，其他进程就无法同时访问该资源。
2.占有和等待：一个进程正在占用资源并等待其他资源被释放，而其他进程正在占用等待被释放的资源，造成进程之间相互等待，形成死锁。
3.不可抢占：已获得资源的进程不能强制地被抢占资源，只能在使用完后自行释放。
4.循环等待：存在一组进程{P0,P1,P2,…Pn}是一个闭环，其中P0等待P1占用的资源，P1等待P2占用的资源，P2等待P3占用的资源，直到Pn等待P0占用的资源。这时候，就形成了循环等待。

22.如何避免死锁？

在多线程程序中，死锁是指两个或多个线程无限期地阻塞等待对方持有的资源，导致程序无法继续执行下去。为了避免死锁，我们可以采取以下措施：
1.加锁顺序要一致。如果多个线程需要使用多个共享资源，为了避免死锁，我们需要规定一个加锁顺序，然后确保所有的线程都按照这个顺序来加锁。
2.设置超时时间。当线程等待某个锁的时间超过设定的超时时间后，就主动释放锁，并退出等待，这样可以避免死锁。
3.使用try_lock()。尝试获取锁，如果获取不到就立即释放锁，然后等待一段时间后再试图获取锁。
4.减小锁的粒度。将一个大锁拆成多个小锁，这样可以减小锁的粒度，缩小锁的范围，从而减少锁冲突的可能性。
5.避免嵌套锁。在一个锁的范围内，尽量避免再嵌套另一个锁的范围，这样可以避免死锁的发生。

23.场景设计题：管理云上主机数500万，数据2G，查询请求1000万/s，更新请求1000/s，如何设计该模块？

对于管理云上主机数500万的场景，可以考虑采用分布式系统来实现。首先，需要将这些主机进行分组，每个组由多台主机组成，并将这些组分布到不同的服务器上。接着，可以采用哈希算法将每个请求映射到相应的组上，以实现负载均衡。对于数据量较大的情况，可以采用分布式数据库来存储数据，同时对于每个请求的查询和更新，可以采用缓存技术来提升响应速度。最后，为了支持高并发的请求，可以采用消息队列来实现异步处理，以提高系统的吞吐量。

二、美团后端暑期实习二面面经

1.进程和线程的区别

进程是操作系统中的独立执行单元，拥有独立的内存空间和资源。线程是进程中的轻量级执行单元，它和其他线程共享同一进程的内存空间和资源。由于线程间共享内存，所以线程间的通信比进程间的通信更加方便和高效。但因为线程间共享内存，一个线程的崩溃可能导致整个进程的崩溃。

2.举个例子:开的这个浏览器属于进程还是线程?牛客网页和其他网页属于多个进程还是多个线程还是怎样?

对于第一个问题，开启的浏览器属于进程，因为它拥有独立的内存空间和系统资源。
对于第二个问题，不同的网页可以属于同一个进程或不同的进程，这取决于浏览器的实现。一些浏览器采用多进程架构，每个网页都在一个单独的进程中运行，这样可以提高浏览器的稳定性和安全性；而一些浏览器采用单进程架构，多个网页则在同一个进程中运行，这样可以减少系统资源的消耗。而多个网页所在的进程可以拥有多个线程，每个线程负责不同的任务，例如渲染网页、处理网络请求等。

3.在实际的项目中用过线程池吗?讲讲当时是什么场景要用线程池?讲讲ThreadPoolExcutor?

线程池典型的使用方式为：
1.使用ThreadPoolExecutor构造函数创建线程池对象；
2.通过execute或submit方法提交任务；
3.根据实际情况调整线程池的配置参数。
对于线程池的使用，我们知道在一个应用程序中，可能需要同时执行多个任务，这时候就需要用到线程池来管理线程。具体来说，线程池维护一个线程队列，任务到来时从线程池中取出一个线程执行任务，任务执行完毕后不立即销毁线程，而是放回线程池中等待下一个任务的到来。这样可以避免线程的频繁创建和销毁，提高系统的性能和资源利用率。
场景上，使用线程池一般适用于需要频繁创建和销毁线程的情况，例如：
1.web服务器中接收请求后需要处理请求，此时可以使用线程池增加并发处理请求的能力；
2.高并发的数据库操作，可以使用线程池分配线程处理数据库请求；
3.大量计算型任务，例如：图像处理、音视频编解码等操作，使用线程池可以充分利用CPU资源，加快任务执行速度；
4.后台任务的执行，例如：日志记录、定时任务等，使用线程池可以保证后台任务被及时执行。
关于ThreadPoolExecutor，它是Java中线程池的实现类，其构造方法中可以设置线程池的核心线程数、最大线程数、线程过期时间、等待队列容量等参数。同时，它也提供了一些重要的方法，例如submit()方法可以向线程池提交一个任务，execute()方法可以执行一个Runnable任务等。线程池的细节使用还请开发者参考Java官方文档或其他相关书籍。

4.通过电脑面试，讲一下从你进入电脑开始，在咱俩之间传输的数据经过了哪些网络节点?服务器?最终怎么到达了我这边?讲讲这个全链条?

我们之间的通信是基于互联网进行的，因此在数据传输的过程中会经过很多网络节点和服务器。
在具体描述全链条之前，我先简单介绍一下互联网的结构。互联网是一个由许多连接在一起的计算机和网络设备组成的网络。这些设备通过各种通信协议和技术相互连接，向全世界无数设备和用户提供信息和服务。
回到我们之间的通信，在你向我发送消息的时候，首先会经过你的电脑上的网络设备(如无线网卡、有线网卡等)，然后进入路由器，再经由网络运营商的服务器进入公网。接下来，数据包会通过一系列的节点和服务器，在网络中寻找到我的服务器所在的位置。这些节点和服务器的具体数量和设置会根据网段的不同而有所不同。
最终，当数据包到达我的服务器之后，我的服务器会进行一系列的解码和处理操作，将消息内容提取出来，再通过网络传输回你的电脑，让你能够看到我的回复。
总之，在我们的通信过程中，数据需要经过多个节点和服务器才能够到达目标设备，它们构成了一个复杂的传输链条。

5.说说你在项目过程中真正的JVM调优经历?聊聊项目

JVM调优的举例可能包括以下几个方面：
1.调整堆空间大小：可以通过-Xms和-Xmx参数来调整JVM堆空间的大小，以适应不同的应用场景。通常建议将-Xms和-Xmx设置为相同的值，以避免在应用程序运行期间频繁进行堆扩展和收缩。
2.调整GC算法：可以通过-X参数来选择不同的GC算法，以适应不同的应用场景。例如，对于需要高吞吐量的应用程序，可以选择并行GC算法；对于响应时间敏感的应用程序，可以选择CMS算法或者G1算法。
3.调整GC参数：可以通过-XX参数来控制GC过程中的各种参数，例如堆大小、年轻代和老年代比例、对象晋升阈值等等。不同的应用程序可能需要不同的GC参数，需要根据实际情况进行调整。
4.调整线程数：可以通过-XX:ParallelThreads参数来控制GC线程数，以充分利用多核处理器。如果线程数过多或者过少都有可能影响GC性能，需要进行适当的调整。
5.使用JIT编译器：可以通过-XX:+UseCompressedOops参数来启用指针压缩技术，以减少对象引用的大小，从而提高JIT编译器的性能。
总之，JVM调优需要根据实际应用场景进行，需要对各种参数和算法进行适当的调整和优化，以提高应用程序的性能和稳定性。

6.项目需求谁输出的?(项目解决什么问题，有哪些用户，干什么事，调研了哪些资料，参考了哪些商业化的软件?)3.产品设计包含的详细业务流程说说?管理员主要做哪些具体的动作?

7.如果用户正在下单一个菜品，但管理员给它下架了怎么处理?

如果用户正在下单一个菜品，但管理员给它下架了，应该向用户发送通知，告知菜品已经下架，不能继续下单。同时，用户的订单中应该移除该菜品，并将已选数量清零。如果用户已经支付，应该及时退款。在日常运营中，应该定期审核已下架的菜品，避免用户遇到此类问题。

8.技术上介绍一下整个项目的架构?

这个项目的架构基于Java语言进行开发，整体采用了分层架构设计，主要分为表示层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）三个层次。
在表示层，我们采用了SpringMVC框架搭建Web应用，对于前端页面的渲染采取了JSP技术和Bootstrap进行美化。在业务逻辑层，我们主要编写了服务接口和服务实现类，其中服务实现类使用了Spring框架进行管理。在数据访问层，我们采用了MyBatis框架，经过针对性的优化，从而达到更好的性能。
此外，我们还采用了一些外部组件，如Redis进行缓存管理、Log4j进行日志处理、Quartz进行定时任务的调度等等。通过这些层次的分明和各个组件的协同工作，最终实现了具有高可用性、高性能、易扩展性等优点的项目架构。

9.集成阿里云短信介绍一下?

10.Redis解决的高并发问题是什么?哪个流程暴露了这个问题?

Redis解决的高并发问题是多个客户端同时对服务器进行读写操作时，容易出现竞争条件，进而造成数据不一致。Redis通过单线程的方式，保证每条命令的原子性操作，避免了竞争条件的产生，从而解决了高并发问题。该问题通常在数据存储和访问的过程中会出现。需要进行数据读取和写入等操作的时候，就容易因为多线程和多进程的情况，而出现不一致性问题。

11.在你的项目中怎么保证Redis和mysql数据一致性?具体怎么实现的你说的方案?耦合度会不会高?5有没有做分表?没做分表但是做了主从复制?主从复制怎么做的?

要保证Redis和MySQL数据的一致性，可以采用以下几种方式：
1.使用Redis作为缓存层：在应用中，访问MySQL数据库前先查询Redis，若Redis中有缓存则直接返回，否则查询MySQL，得到结果后将结果存入Redis中。为了保证一致性，应该使用缓存穿透技术和缓存雪崩技术，避免MySQL连接池的连接被耗尽。
2.Redis与MySQL双写：每次插入、更新、删除MySQL中的数据时，都同时更新Redis中的缓存数据。这样可以确保MySQL中的数据和Redis中的数据一致性。
3.Redis的Expirable Key特性：Redis支持设置键值对的过期时间，可以通过设置短暂的过期时间，让Redis中缓存的数据与MySQL中的数据保持同步。
4.Redis Sentinel:Redis Sentinel是Redis的高可用解决方案，通过master/slave模式保证数据的高可用性和可靠性。当主服务器宕机时，Sentinel会自动将其中的一个从服务器升级为主服务器，从而保证数据的可用性和一致性。
因此，我们需要根据不同的场景和需求选择不同的方式来解决Redis和MySQL数据一致性问题。

MySQL主从复制是一种基于二进制日志文件的数据复制技术，用于将一个MySQL数据库实例的数据复制到另一个MySQL数据库实例中。下面是MySQL主从复制的简单步骤：
1.配置主服务器：在主服务器中，需要启用二进制日志功能，并对其进行适当的配置。必须确保日志格式为 ROW 或 MIXED。
2.配置从服务器：在从服务器中，需要指定主服务器的IP或主机名、用户名、密码以及要复制的二进制日志文件名和位置。
3.启动主服务器二进制日志文件：启动主服务器的二进制日志文件，以便从服务器可以访问并复制它。
4.启动从服务器复制进程：启动从服务器复制进程，并确保它已正确连接到主服务器。可以使用命令SHOW SLAVE STATUS命令检查复制进程的状态。
5.监视主从复制：可以使用命令SHOW MASTER STATUS和SHOW SLAVE STATUS 来监视主从复制的状态。过程中可能会出现错误，需要进行排除。
需要注意的是，主从复制是一种异步复制，也就是主服务器中更改数据后不会马上在从服务器中被更新，可能会有一些延迟。此外，主从复制还需要对数据一致性进行管理，以确保数据的准确性。

12.主从同步的原理?

数据库主从同步是指数据库主库中的数据与从库中的数据保持同步的机制。其原理是主库与从库之间建立一个同步通道，主库将数据变更通过通道同步给从库，在从库上执行相同的操作，保证从库中的数据与主库中的数据保持同步。通常使用“数据复制”的方式实现主从同步。
Redis主从同步的原理是通过主节点将自己的数据变更同步给从节点来实现的。主节点作为数据的源头，会将每一次的数据变更操作记录在自己的操作日志中，并将日志同步给从节点。从节点会定时向主节点发送同步请求，主节点收到请求后，将日志中未同步的操作发送给从节点，并在发送成功后将已同步的操作标记为已同步，以避免同一操作被重复发送。从节点接收到操作后，执行相应的操作，并在本地记录同步的位置，以便于下一次同步请求时，只需要将从该位置以后的未同步操作发送即可。通过这种方式，主节点和从节点能够保持数据的一致性。

13.主从延迟很高的场景下，写操作最后会不会成功写到主库里?

在主从延迟很高的场景下，写操作不一定能够成功写到主库里。延迟高可能会导致从库与主库之间的数据不一致，而写操作可能会写入从库中，而不是主库。因此，在这种情况下，应该采取措施来保证数据的一致性，例如使用同步或异步复制来保证主从之间的数据同步。同时还需要考虑使用一些机制来监控主从之间的延迟，及时发现并解决数据同步的问题。

14.项目最终怎么做的全流程测试? 测试checklist怎么做?测试用例怎么写的?

针对项目的全流程测试，我们的测试团队会基于测试checklist和测试用例进行测试。测试checklist是指测试人员根据自己的经验和项目需求制定出的详细测试清单，用来保证测试的全面性和严谨性。测试用例则是对每一个测试点进行详细的测试步骤和预期结果的描述，用来保证测试的可重复性和准确性。
在制定测试checklist时，我们会考虑项目的功能需求、非功能需求、安全性、兼容性、可靠性等方面，对各个测试点进行分类和详细描述，确保测试全面覆盖到相关的功能和质量要求。
而在编写测试用例时，我们会针对每个测试点进行详细的测试步骤描述，包括测试输入数据、预期输出结果、测试步骤、测试环境等信息，同时根据测试类型进行测试用例分类和划分，确保测试用例有效性和覆盖度。

以上是我们的全流程测试方案，

15.你上了Redis没做压测吗?

可以使用Redis自带的性能测试工具redis-benchmark进行压测。具体使用方式如下：
1.打开终端，输入redis-benchmark命令，并输入相应的参数：
redis-benchmark -h [host] -p [port] -c [connections] -n
其中：
-h：Redis服务器所在的主机地址，默认为127.0.0.1；
-p：Redis服务器所监听的TCP端口，默认为6379；
-c：并发连接数，默认为50；
-n：请求数量，默认为1000。
例如，输入以下命令，对本地Redis服务器进行50个并发连接，共10000次请求的性能测试：
redis-benchmark -c 50 -n 10000
2.命令执行完毕后，会输出测试结果。常见的测试结果包括：每秒钟可处理的请求数量（Requests per second）、平均每个请求的响应时间（Average response time）等。可以根据需要自行选择输出指标。
需要注意的是，压测时最好使用和实际运行环境相同规格的机器进行测试，并且不要过度压测，以避免对系统造成太多负担。

16.前端用了什么框架?你会不会写前端代码?会用什么前端框架?

三、平安证券一面

1.HashMap的底层原理，是否可以存对象

HashMap的底层原理是基于数组和链表（或红黑树）实现的。每个键值对被存储在一个Entry对象中，这个Entry对象包含了键、值、下一个节点引用等信息。当键值对被加入HashMap中时，先根据键的HashCode值来决定存储位置，如果这个位置已经有其他键值对了，就会发生碰撞，这时候会把这个键值对插入到链表的末尾，或者如果链表过长（大于8）则转化为红黑树来存储。因此，HashMap的底层原理可以支持存储对象类型的键和值。

2.Mysql的索引，b树和b+树的详细区别

Mysql的索引分为多种类型，其中B树索引是最常用的一种索引类型。B树是一种平衡的树形结构，可以高效地实现查找、插入和删除操作，比如常见的二叉搜索树就是一种B树。而B+树相比B树，它的非叶子节点不存储数据，只存储索引信息，叶子节点则按照索引顺序存储数据。B+树在查询数据时效率更高，因为它只需要搜索到叶子节点即可获取全部数据，而B树需要搜索到与关键字对应的节点。此外，B+树还可以更好地支持区间查询。
总之，B树和B+树都是常用的索引类型，其中B+树更适用于范围查询。在使用Mysql时，我们可以根据数据的特点来选择不同类型的索引以达到更高的查询效率。感谢您的提问，希望能够帮助到您。

3.多线程的创建、volatile和synchronized的详细区别，原子性；创建线程的时候run()和start()的区别

多线程的创建需要继承Thread类或实现Runnable接口并重写run()方法。
volatile是一种关键字，表示变量的值可能随时都会发生变化，因此使用volatile声明的变量可以在多线程环境中通过多个线程共享。而synchronized关键字则是用来解决多线程访问共享资源时产生的同步问题，它可以使得多个线程在并发访问时，保证共享资源的同步性。
原子性是指一个操作是不可中断的整体，要么全部执行成功，要么全部执行失败，不会出现执行了部分操作的情况。在多线程环境中，若多个线程同时执行某个操作，可能会存在竞争，从而出现执行了部分操作的情况。为了解决这个问题，Java提供了Atomic包，它封装了一些能够保证原子性的操作，如incrementAndGet()、decrementAndGet()、compareAndSet()等。
创建线程时，调用start()方法会将线程纳入操作系统进行调度，然后由操作系统在适当的时候启动该线程，并自动调用该线程的run()方法；而直接调用run()方法并不会启动新线程，而是在当前线程中直接调用run()方法执行。因此，我们通常应该调用start()方法来启动线程。

4.垃圾回收机制，其中方法区里面存的是什么东西，什么时候会出现内存溢出的问题

垃圾回收机制是一种自动内存管理的机制，在Java虚拟机中，垃圾回收器主要对堆区进行垃圾回收。堆区是Java虚拟机运行时存储对象所分配的内存区域，主要包括新生代和老年代，其中新生代又分为Eden区、Survivor0区和Survivor1区。方法区存储的是类的元数据信息，比如类名、方法名以及字节码等信息。
在堆区中，当对象不再被引用时，会被标记为垃圾对象，等待被垃圾回收器回收。在标记清除、复制和标记整理等垃圾回收算法中，如果没有足够的内存空间去存储新对象了，就会发生内存溢出的问题。
而在方法区中，由于它存储的是元数据信息，所以它的数量有限。当Java虚拟机加载大量的类或者反射生成大量的动态代理的时候，就有可能出现方法区的内存溢出问题。其中常见的方法区的内存溢出异常就是PermGen space异常。为了解决这个问题，可以通过设置适当的虚拟机参数或者升级虚拟机的方式来解决。

5.equals和==的区别，引申到hashmap的存储，两个对象用equals判断相等和不相等的时候，hashmap里面怎么存储

equals和的区别在于，equals比较的是两个对象的内容是否相同，而比较的是两个对象的引用地址是否相同。在hashmap中，当两个对象使用equals比较时返回相等，hashmap会先使用对象的hashCode()方法生成一个hashCode，根据这个hashCode来确定对象在HashMap中的存储位置。如果两个对象使用equals比较返回不相等，则会被存储在哈希表中的不同位置。但是，当两个对象使用==比较时返回true时，它们的hashCode必须相同才能被存储在HashMap的同一位置上。否则，它们将被存储在不同的位置上。

6.String这个类的特点是什么，在jvm里面是怎么存的；

String是Java中的一个类，用于表示字符串。它的特点是字符串内容不可变，也就是说，创建一个字符串后，不能对其内容进行修改，但是可以通过创建新的字符串来实现修改。
在JVM中，String被存储在字符串常量池中，该常量池是JVM中的一块特殊的内存，用于存储字符串常量。当程序创建一个字符串时，如果字符串常量池中已经存在相同内容的字符串，那么该字符串将被重用，否则会创建一个新的字符串，并将其添加到字符串常量池中。因此，字符串在JVM中是可以共享的，这种机制可以大大减少内存的占用。

7. hashtable的底层原理

HashTable（哈希表）是一种数据结构，底层原理就是将要存储的键值经过哈希算法转换成一个索引值，然后将该键值存储在索引值所代表的数组或链表中，以便于快速查找和访问。当需要查找或者插入时，我们先利用哈希算法计算出对应的索引位置，然后再进行相关操作。常用的Hash算法有除留余数法、平方取中法、冲突解决法等。

8.项目：说一下spring aop的应用，拦截器的具体内容、邮箱注册的详细实现(这个有点忘了)

关于spring aop的应用，通常用于实现切面编程，拦截器的具体内容包括拦截器类的定义和实现，拦截器配置文件的配置和使用方式。拦截器可以用来控制方法执行前后的逻辑，例如日志记录、权限控制、缓存控制等等。
对于邮箱注册的详细实现，通常包括：用户输入邮箱地址并提交表单、后端服务器接收到请求后，对邮箱地址进行合法性检查并生成验证码，将验证码发送给用户、用户收到验证码后输入验证码并提交表单、后端服务器接收到请求后，再次验证邮箱地址和验证码的正确性，如果验证通过则注册成功。具体实现可以使用JavaMail库来实现邮件发送和验证码处理。

四、美团后端暑期实习一面

1.介绍一下移动实习项目具体内容，大概是一个多大的项目组，你在项目组里主要负责什么模块?

2.为什么选择redis做高并发性能处理方案，选择的思路?

Redis是一个内存型数据库，相比传统硬盘型数据库，它具有操作简单且速度快的优势。针对高并发，可以使用Redis实现缓存措施，将常用的数据缓存在Redis中，并且可以通过Redis集群的方式实现数据的分布式存储，进一步提升并发性能，降低单点故障的风险。另外，Redis还支持多种数据结构，如字符串、哈希表、列表等，可以方便地满足不同的场景需求。综上所述，选择Redis作为高并发性能处理方案，主要基于其快速、简单、高效的特点以及对数据结构的支持。

3.主从复制部署方案?你在服务器上部署它的实例吗?还是有人专门维护这个?

Redis主从复制部署方案可以分为以下步骤：
1.准备主数据库和从数据库：在服务器上配置 Redis 主从复制前，需要准备好主数据库和从数据库，可以在同一台机器上配置不同的端口，或者在不同的机器上安装 Redis。
2.设置 Redis 主节点：在主节点的 Redis 配置文件 redis.conf 中，添加配置项 slaveof no one，表示该节点为主节点。启动 Redis 服务。
3.设置 Redis 从节点：在从节点的 Redis 配置文件 redis.conf 中，添加配置项 slaveof 主节点的 IP 地址 主节点的端口号，表示该节点为从节点。启动 Redis 服务。
4.验证 Redis 复制是否成功：可以使用 Redis 客户端查看主从节点的状态。在主节点上插入一条数据，从节点也应该同步插入相同的数据。
5.添加备份机制：为了保证数据安全，可以在主节点进行备份，可以使用 Redis 自带的 bgsave 命令备份数据，并将备份文件定时同步到从机节点。
总之，Redis 主从复制可以实现数据的高可用性和容错性，适用于需要高并发和数据一致性的场景。

4.读写分离会不会出现主从不一致的情况?如何解决?

对于读写分离的系统，主从不一致是一种常见的问题，可能会导致数据的不一致性和可靠性问题。为了解决这个问题，可以采取以下几种方式：
1.强制同步：在某些场景下，我们可以强制要求主节点和从节点必须保持同步。例如，在写操作完成之后，强制同步更新从节点，等待从节点确认成功后再返回成功给应用程序。
2.时延容忍：对于一些对数据一致性要求不是十分高的应用，我们可以允许出现一定时延的主从不一致情况，而不是必须保证实时同步。我们可以通过设置同步的时间间隔或者采用异步复制的方式，来减少主从同步过程中对应用的影响。
3.负载均衡：合理的负载均衡也可以降低主从不一致的概率，例如将读请求更多的分流到从节点上，写请求则发送到主节点上，这样可以减轻主节点的压力，降低主节点宕机或故障的概率。
4.数据复制与恢复：在主从不一致的情况下，如果从节点的数据已经严重落后于主节点，可以通过数据复制和恢复的方式来解决。例如，重新将主节点上的数据复制到从节点上，然后保证后续的主从同步正常进行即可。
以上是一些解决主从不一致的常见方式，实际上还可以根据不同的业务需求和场景采取不同的数据同步策略。

5.异常处理机制的实现方案?所捕获的异常是直接用的Exception.class吗?

Java中的异常处理机制通过try-catch语句块实现。Java中有一个Throwable类作为所有异常的基类，包括Error和Exception。Exception是程序运行时出现的一种可处理的异常，而Error是指发生的严重问题无法通过程序处理，需要人工介入解决。
在try块中可能会抛出异常，而在catch块中则会处理这些异常。捕获异常时可以使用Exception类来处理所有类型的异常，也可以使用各个异常类型的专用类来处理特定的异常。
所以捕获的异常可以是Exception.class，也可以是任何继承自Exception的子类。

6.简单介绍一下树形表的模型?

树形表是一种基于树形结构存储数据的数据模型。它类似于关系型数据库中的表格，但是不同的是它使用树形结构代替了平面结构，可以更加直观地描述数据之间的层次关系。在树形表中，每个节点都可以有多个子节点，但是只能有一个父节点。一般来说，树形表中的节点表示的是某个实体，而节点之间的关系则代表不同实体之间的关联关系。树形表可以应用于很多领域，比如金融、物流、教育等等。

7.用的Spring Cloud Nacos什么功能?配置中心主要用来控制哪些变量?

Spring Cloud Nacos实现配置中心主要用来控制应用程序的配置变量。这些变量包括但不限于数据库连接信息、日志级别、Redis的连接信息等。Nacos可以将这些变量的值存储在中心化的存储库中，并且可以动态地将其分发给运行在不同服务器上的应用程序。这样，应用程序就可以维护它们的配置值，并且可以根据需要进行动态更改，而无需重新启动应用程序。

8.Spring Cloud Feign底层原理是什么?

Spring Cloud Feign 是一个声明式的 Web Service 客户端，通过使用 Feign，我们只需要定义服务绑定接口、处理请求参数等，Feign 就会根据定义生成请求 URL，然后进行请求的发送。它底层是通过动态代理方式生成了一个接口的实现类，并且维护了一些内部状态信息，从而实现了对 HTTP API 的封装和调用。具体实现方式是使用了 Spring MVC 中的 RestTemplate，它是基于 HTTP 协议的，通过发送 HTTP 请求并解析响应，来完成数据的传输。

9.Hashmap原理?负载因子为什么设成0.75?

Hashmap是Java中的一种数据结构，其基本原理是使用哈希函数将键映射到存储桶中，然后在桶内搜索键的值。
负载因子是指哈希表中存储的元素数量占哈希表容量的比例，当元素数量到达负载因子设定值时，就会触发哈希表的扩容操作。将负载因子设定为0.75，是为了在保持哈希表性能的同时减小空间开销和冲突的可能性，因为在0.75这个比例下，哈希桶的利用率最高。

10.ConcurrentHashMap原理?

ConcurrentHashMap 是 Java 中的一个线程安全的哈希表实现，它主要是为了在高并发场景下提供高效的并发访问性能。它的原理是通过将数据分割成多个片段（Segment），每个片段相互独立，同时进行并发访问，从而实现了更高的并发度。每个片段内部仍然使用哈希表的方式进行数据存储和访问。因为每个片段在进行操作时只涉及到一个小的数据范围，所以锁的粒度更小，从而提高了并发效率。

11.同步和ReentrantLock区别?

同步和ReentrantLock都可以实现多线程同步的效果，但是有一些区别。
同步是Java中的一种机制，它通过synchronized关键字来实现。同步只有一种锁，即对象锁，一个对象只有一把锁。在锁定对象时，其他线程无法获得锁，进入等待状态，该锁释放后，其他线程才能获得锁进行访问。
而ReentrantLock是一个可重入的互斥锁，它具有与同步不同的特性。ReentrantLock可以重复地获得锁，如果一个线程已经获得了该锁，可以再次获得该锁，而不会发生死锁。此外，ReentrantLock提供了更多的方法和灵活性，比如可以设置等待超时时间、中断等待等。需要手动释放锁，不像同步会自动释放锁。
总的来说，当我们需要更高级的功能，比如可重入锁、公平锁、超时锁等，可以考虑使用ReentrantLock。而对于一些简单的同步需求，synchronized已经足够。

12.AQS原理?

AQS（AbstractQueuedSynchronizer）是Java中一种实现锁和相关同步器的框架。它是基于一种先进先出（FIFO）的等待队列来实现线程的排队和阻塞机制的。AQS的实现原理是通过一个共享变量state来标志资源的占用情况，当state的值为0时，表示该资源没有被占用，当state的值不为0时，表示该资源已经被占用。进入临界区的线程需要进行CAS操作来获取state值，如果获取成功，表示该线程占用了资源，如果获取失败，表示该线程需要进入等待队列排队。当资源被释放时，需要通过CAS操作将state的值置为0，并从等待队列中唤醒排队线程，让其抢占资源。这种同步工具可以被用于实现诸如ReentrantLock、Semaphore、CountDownLatch、Condition等同步工具。

13.GC垃圾回收方法?

GC（垃圾回收）是一种自动内存管理的机制，用于监控和回收不再使用的内存。在 Java 中，垃圾回收器会自动回收不再使用的对象，从而释放内存。Java 中有多种垃圾回收方法，如标记-清除、复制、标记-整理等。具体选择哪一种方法，取决于应用程序的内存情况和性能要求。

14.新生代进入老年代有哪些条件?7.提到的新生代16次就GC进入老年代，年龄最大是多少?

新生代对象进入老年代的条件有两个：一是对象年龄达到了阈值，二是新生代空间不足。至于第二个问题，年龄最大为15岁，因为新生代默认的对象年龄阈值为15。

15.主要的存储引擎?

主要的存储引擎有许多种，其中比较流行的有MySQL的InnoDB引擎、MongoDB的WiredTiger引擎、Redis的RDB和AOF引擎等。选择存储引擎需要考虑应用场景、数据类型、性能需求等方面的因素。

16.InnoDB和MyISAM的区别?

InnoDB和MyISAM是MySQL数据库的两个不同的存储引擎。其中，InnoDB主要适用于大量高并发事务的应用程序，具有良好的ACID事务支持和行级锁定能力，支持外键约束、表空间自动扩展等功能；而MyISAM则适用于读多写少的应用程序，具有较高的查询速度和压缩存储能力，但不支持事务和行级锁定，不支持外键约束和表空间自动扩展。在使用时，需要根据应用程序的具体需求和使用环境选择适当的存储引擎。

17.InnoDB和MyISAM底层实现B+树的区别?

InnoDB 和 MyISAM 在底层实现 B 树的方式上有一些不同。InnoDB 采用聚簇索引的方式来实现 B 树，聚簇索引是把数据和主键放在一起存储。而 MyISAM 则是用非聚簇索引的方式来实现 B 树，非聚簇索引是把索引和数据分别存储。由于 InnoDB 的实现方式，因此它是一种更加适合高并发写入的存储引擎，而 MyISAM 则更适合读取操作更多的场景。

18.Mysql隔离级别?默认隔离级别?

Mysql有四个隔离级别，分别是读未提交（Read uncommitted）、读已提交（Read committed）、可重复读（Repeatable read）和串行化（Serializable），其中默认的隔离级别是可重复读（Repeatable read）。

19.可重复读实现原理?

可重复读是指在同一个事务中，多次读取同一数据，得到的结果应该是一致的。实现可重复读需要满足以下两个条件：
1.在事务中，读取的数据不能被其他事务修改。
2.读取的数据不能被当前事务修改。
为了实现这些条件，数据库系统会使用多版本并发控制（MVCC）技术。在MVCC中，每一次修改都会给数据生成一个版本号，读取操作只会返回版本号早于当前事务开始时间的数据，而写操作只会对数据生成新的版本号。这样，就能保证在同一个事务中，多次读取数据得到的结果是一致的。

20.Mysql具体的检索流程?比如给你一个查询语句?

当我们执行一条查询语句时，MySQL实际上需要执行很多操作。以下是MySQL检索流程的一般步骤：
1.语法分析
MySQL会首先对查询语句进行语法分析，以确保它符合SQL语言的规范。如果查询语句存在语法错误，MySQL将返回一个错误消息。
2.查询优化器
MySQL会根据查询语句的内容来进行分析，找出最优的执行方案，以保证查询语句尽可能快地执行。
3.查询执行器
一旦查询优化器确定了执行方案，MySQL将会调用执行器来执行查询语句。执行器会根据查询语句的内容来执行各种操作。
对于具体的查询语句，例如：
SELECT * FROM customers WHERE name = ‘John’;
MySQL将会执行以下步骤：
1.语法分析并确定查询对象（customers）和查询条件（name = ‘John’）
2.查询优化器分析查询语句并建议最优查询计划
3.执行器执行查询，打开表格，查找满足查询条件的数据，并将结果返回给客户端

21.文件夹日志和重做日志?

MySQL 中的文件夹日志和重做日志是 InnoDB 存储引擎的日志文件，用于记录数据库的变化及事务信息。
文件夹日志也称为事务日志，用于记录在数据库中执行的所有修改操作，包括增删改操作。重做日志则是用于数据库崩溃恢复的日志，用于在 MySQL 重新启动时，重新执行一次恢复操作，确保数据库的数据完整性。
同时，文件夹日志和重做日志都是循环写入的，即写入一定量数据后，就会把这些数据转移出去，写到下一个日志文件中。这样可以确保日志文件不会无限增大，同时也可以保证在 MySQL 重启后能够正常恢复数据。

22.为什么mysql底层使用B+树不使用二叉树、红黑树等等?

MySQL底层使用B树而不是二叉树、红黑树等等的原因是B树可以更好地适应磁盘数据存储的特点，而这些树在磁盘数据存储时效率并不高。B树通过将节点合并、分裂等操作来保持树的平衡，从而优化磁盘IO操作，减少对磁盘的访问次数，提高执行效率。此外，B树也可以支持范围查询等操作，更适用于MySQL这种关系型数据库系统的实际应用。

23.建表为什么用自增主键?为什么不用uuid?

建表使用自增主键的主要原因是出于性能和简易性的考虑。自增主键可以确保每一行数据的唯一性，并且在插入数据时无需指定主键的具体值。此外，在大量数据插入的情况下，使用自增主键可以提升插入效率，因为数据库可以自动为每一行数据指定一个递增的整数值作为主键。
相比之下，使用 UUID 作为主键可能会导致性能下降。因为 UUID 是随机生成的字符串，其不同的值是没有规律可循的，会导致索引树节点的频繁分裂和合并。此外，UUID 的长度相对较长，会占用更多的存储空间。因此，在实际应用中，建议使用自增主键而不是 UUID 作为表的主键。

24.Redis数据类型?

Redis支持多种数据类型，包括字符串（string）、列表（list）、集合（set）、有序集合（sorted set）、哈希表（hash）和流（stream）。每种数据类型都有自己的使用场景和特点。

25.Zset底层实现原理?

Zset是Redis中的有序集合数据结构，它的底层实现是基于跳跃表和哈希表的。跳跃表是一种随机化数据结构，可以快速地搜索和插入元素，它在实现有序集合的过程中主要负责排序和查找功能。而哈希表则是为了支持快速的插入、删除和查找操作。在实现有序集合时，哈希表主要负责维护每个元素及其对应的分值，在跳跃表上快速定位元素。

26.Redis持久化机制?

Redis持久化机制有两种，分别为RDB和AOF。
RDB是指Redis Database Backup（Redis数据库备份），它是一种将Redis在内存中的数据定期持久化到硬盘上的方法。当Redis拥有大量数据时，使用RDB会更加高效，因为在恢复数据时会比AOF更快速。RDB的优点包括备份的文件小、恢复数据速度快，缺点是定期备份的话，可能会存在数据损失的风险。
AOF是指Append Only File（追加文件），它是通过将Redis收到的每个写操作追加到文件末尾中，达到持久化的目的。AOF的优点是可以满足更高的数据安全性，因为每次写操作都会被记录，此外也支持数据即使恢复，而缺点是文件较大，恢复数据速度慢。
总的来说，RDB适用于数据量较大时的备份，而AOF适用于对数据安全性有较高要求的场景。

27.Sql调优?

SQL 优化的方法有很多，比如：1、使用合理的索引；2、优化 SQL 语句；3、使用存储过程；4、使用合理的数据库设计；5、使用合理的查询结构；6、使用合理的查询优化器；7、合理分片；8、使用合理的缓存策略；9、使用合理的数据库集群；10、使用合理的数据库优化器。

28.Bean的生命周期?

Bean的生命周期可以分为以下几个阶段：

1.实例化：在容器启动时，通过反射或工厂方法等方式创建Bean实例。
2.属性注入：将Bean所需的属性值通过依赖注入的方式注入到Bean中。
3.BeanPostProcessor的前置处理：在Bean实例化并注入属性后，容器会调用所有实现了BeanPostProcessor接口的实现类的postProcessBeforeInitialization方法，完成一些初始化的工作。
4.初始化：调用Bean的初始化方法，可以通过实现InitializingBean接口或在配置中指定init-method来指定初始化方法。
5.BeanPostProcessor的后置处理：在Bean初始化完成后，容器会调用所有实现了BeanPostProcessor接口的实现类的postProcessAfterInitialization方法，对Bean进行加强处理。
6.使用：Bean现在可以被容器注入到其他Bean中使用。
7.销毁：当容器关闭时，会调用Bean的销毁方法，可以通过实现DisposableBean接口或在配置中指定destroy-method来指定销毁方法。

29.Spring事务?事务的传播级别?Linux常用命令?vim后要将A字符全部替换为B用哪个命令?

1.Spring事务：Spring事务是一种管理数据库事务的机制，用于在应用程序中控制数据库事务的执行状态。Spring事务主要通过@Transactional注解来实现。在使用Spring事务时，需要了解事务的传播级别，包括：REQUIRED（默认模式）、REQUIRES_NEW、SUPPORTS、NOT_SUPPORTED等，不同的传播级别具有不同的功能和应用场景。
2.Linux常用命令： Linux常见的命令非常多，其中一些比较常用的包括：
cd：切换目录
ls：查看目录中的内容
pwd：显示当前的工作目录
mkdir：创建新的目录
touch：创建新文件
rm：删除文件或目录
grep：查找行中的文本
tar：压缩和解压缩文件
ps：列出当前正在运行的进程
top：实时查看系统进程状况
ifconfig：显示当前网络配置
netstat：显示网络连接状态
ssh：远程登录其他计算机
3.vim中将A字符全部替换为B的命令是：:%s/A/B/g。其中的“%”表示对整个文档进行操作，“s”表示替换操作，“/A/B/g”表示将文档中所有的A字符都替换为B。

30. 算法题：懒汉单例模式2从中序和后序数组中创建二叉树

五、百度云

1.二分查找

二分查找是一种在有序数列中查找某个特定元素的搜索算法。它的基本思想是，将数列的中间位置的元素与要查找的元素进行比较，如果相等则搜索成功，否则将数列分为两半，将要查找的元素与较小的半部分进行比较，如果小于则在较小的半部分进行搜索，如果大于则在较大的半部分进行搜索。这样可以不断地将搜索范围缩小，直到找到要查找的元素为止。二分查找的时间复杂度为 O(logn)，因此它是一种非常高效的搜索算法。
算法流程如下：
1.从数列的中间位置开始搜索，将中间位置的元素与要查找的元素进行比较。
2.如果相等，则搜索成功；如果要查找的元素小于中间位置的元素，则在较小的半部分进行搜索；如果要查找的元素大于中间位置的元素，则在较大的半部分进行搜索。
3.重复步骤 1 和 2，直到找到要查找的元素或者数列被缩小为空为止。

2.合并二叉树

合并二叉树是指将两个二叉树合并为一个新的二叉树，新的二叉树的节点是原来两个二叉树对应节点的值的和。如果两个二叉树的对应节点只有一个有值，那么新树的对应节点的值就是有值的那个节点的值。

3.挖项目，谈谈你对docker的理解?

Docker是一种容器化技术，可以将应用程序及其依赖项封装到独立的容器中运行，从而实现应用程序在不同的环境中高效、可移植地运行。Docker可以简化应用程序的部署、扩展和管理，提高开发效率和运行效率。它提供了一种轻量级的虚拟化解决方案，可以在同一主机上运行多个容器，以实现更高的资源利用率。Docker还支持容器编排和管理工具，如Docker Compose和Kubernetes，进一步提高了容器化应用程序的可扩展性和可靠性。

4.docker和虚拟机有什么区别?docker底层是如何做这个资源隔离的?

Docker与传统的虚拟机技术相比，最大的区别是它采用了轻量级的进程(容器)隔离技术，而非完全的硬件虚拟化，从而可以实现更高效的资源利用和更快速的部署。相对于虚拟机而言，Docker 省去了 Guest OS 的资源占用和启动时长，使得每台主机上可以同时运行更多的应用实例，下降了不必要的成本。
在Docker底层实现上，它使用了Linux 内核中的cgroups 和 namespace 等技术，通过限制容器内进程的资源使用，来实现资源隔离的目的。其中 cgroups 主要负责对 CPU、内存、磁盘等资源进行限制和管理，而 namespace技术则负责对容器内进程的视图进行隔离，使得容器内的进程只能看到自己的进程和文件系统等资源，而与主机和其他容器隔离开来。这些技术结合在一起，使得Docker可以快速高效的创建、启动、停止和销毁容器，从而实现快速部署和更新。

5.JDK中的SPI机制是怎么实现的?Spring实现的 SPI了解过吗?

SPI（Service Provider Interface）是指一种服务发现机制，它通过约定的方式，为某个接口寻找服务实现的机制。在JDK中，SPI机制是通过在JAR包的META-INF/services目录下创建一个以服务接口全限定名命名的文件，文件内容为实现该服务接口的具体实现类的全限定名，从而实现对服务提供者的发现。Spring也使用了SPI机制，通过约定，让用户可以在系统启动时将某些组件注册到容器内。
对于Spring的SPI实现，Spring会在classpath下寻找META-INF/spring.factories文件，该文件中列出了实现了某个接口的所有类，Spring会自动将这些类实例化，并将它们添加到容器中。Spring的SPI机制是其插件化体系的基础。

6.场景:Dubbo中热插拔导致的资源未回收怎么处理?比如说SPI创建对象，如果说这个对象中开辟了线程池.那么热插拔的时候，如何来释放这个线程池的资源如何平滑地承接流量，如何真实地load进去呢?怎么实现无感?

关于Dubbo中热插拔导致的资源未回收的问题，通常有以下几种处理方式：
1.在使用SPI创建对象时，确保对象内部的线程池等资源都可以被销毁或释放，这样在热插拔时就不会有资源未释放的情况了。
2.在热插拔时，需要手动停止或销毁相关资源，确保其被正确回收。
3.使用一些框架或工具来进行资源管理，比如Dubbo中提供的ExtensionLoader的destroyAll等方法，可以帮助自动销毁资源等。
关于如何平滑地承接流量，可以考虑在热插拔时使用一些负载均衡策略来保证流量的平稳过渡。比如在热插拔时，可以先将新的服务节点权重设置为较小值，然后逐渐增加权重，直到达到正常的负载均衡状态。
最后，为了实现无感的热插拔，可以使用一些高可用性方案，比如使用Zookeeper这样的注册中心，在热插拔时，先将新节点注册到Zookeeper中，然后在逐步切换流量过去，直到旧节点不再接收请求。这样可以确保热插拔过程中不会导致服务的中断或异常。

7.Dubbo中的SPI机制和JDK中SPI机制是如何实现的?

Dubbo中的SPI机制是基于JDK中的SPI机制实现的。Dubbo中SPI的实现方式与JDK中的SPI机制类似，都是基于Java提供的ServiceLoader实现的。具体来说，Dubbo中的SPI机制通过在类路径下的META-INF/services目录下创建对应的配置文件，来指定对应的实现类，然后通过ServiceLoader.load()方法进行加载，从而实现对应的功能扩展。与JDK中的SPI机制类似，Dubbo中的SPI机制也提供了相应的注解@SPI来指定默认的SPI实现类。通过指定@SPI注解和使用接口代表不同的扩展点，Dubbo中的SPI机制可以方便地实现对不同功能的扩展。

8.负载均衡算法知道哪些?项目中怎么使用的?

负载均衡算法包括轮询、随机、哈希、最小连接数等，它们的目的是将服务请求分配到多个服务器上，以达到负载均衡的效果，提高整个系统的可用性和可伸缩性。在项目中，我们使用了Nginx作为反向代理服务器来实现负载均衡。通过配置NGINX的UPSTREAM，使用多个服务器进行负载均衡。同时，我们根据实际的业务情况选择了轮询算法，即根据每个服务器的负载情况轮流分配请求。这样可以确保每台服务器都能够承担相同的压力，提高系统的可用性和稳定性。

9.场景:加权轮询导致的问题?比如说10台主机，每次加权轮询都打到同一台主机上，这样可以吗?

加权轮询导致的问题，如果设置不当可能会导致一些主机得到的流量过多，而其他主机得到的流量过少。如果有10台主机，每次加权轮询都打到同一台主机上，这样是不合理的。合理的做法是设置合理的权重，让请求在各台主机之间均匀分配，确保各主机得到合理的流量

10.Redis

Redis是一款高性能的开源的键值对存储数据库。它支持多种数据结构，包括字符串、哈希、列表、集合和有序集合等。 Redis的优点有快速读写速度，数据持久化，分布式支持等，非常适合做缓存系统。同时，Redis也支持Lua脚本扩展和事务等高级功能。

六、 腾讯云智 后台实习一面

1.Object类有哪些方法

Object类有以下方法：
1.clone()：创建并返回当前对象的一个副本。
2.equals()：比较两个对象是否相等。
3，finalize()：在垃圾回收器将对象回收之前调用（已过期，不建议使用）。,
4.getClass()：返回此对象运行时类的引用。
5.hashCode()：返回对象的哈希码值。
6.notify()：唤醒正在等待该对象监视器的单个线程。
7.notifyAll()：唤醒正在等待该对象监视器的所有线程。
8.toString()：返回对象的字符串表示形式。
9.wait()：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法。
10.wait(long timeout)：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法，或者指定的时间到期。
11.wait(long timeout, int nanos)：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法，或者指定的时间到期。

2.比较两个引用对象 == 和 equals方法的区别

两个引用对象的 == 比较的是它们在内存中的地址是否相同，如果相同则返回true，否则返回false；而equals()方法比较的是两个对象的内容是否相等，如果相等则返回true，否则返回false。需要注意的是，equals方法必须重写，否则默认情况下与 == 操作符相同，只是比较的是对象在内存中的地址。

3.谈谈hashcode方法和equals方法的关系

hashcode方法和equals方法是Java中Object类的两个重要方法，它们之间是有一定关系的。equals方法用来判断两个对象是否相等，而hashcode方法则返回对象的哈希码值。
在Java中，当我们需要将对象存储到一些集合类中，例如HashSet和HashMap时，会用到hashcode方法和equals方法。HashSet和HashMap底层都是基于哈希表实现的，而哈希表需要用到hashcode方法和equals方法来判断对象是否相等，以及决定对象在哈希表中的存储位置。
如果两个对象的equals方法返回true，那么它们的hashcode值应该相等。因此，重写equals方法时，也需要重写hashcode方法，以保证相等的对象具有相等的哈希码。
需要注意的是，即使两个对象的hashcode值相等，它们也可能不相等。这种情况被称为哈希冲突。在哈希冲突的情况下，哈希表会使用equals方法再次比较两个对象是否相等。因此，在重写equals和hashcode方法时，需要保证两个方法的一致性。即如果两个对象的equals方法返回true，那么它们的hashcode值一定相等。

4.HashMap如何判断相同元素

在Java中，HashMap通过hashCode和equals方法来判断元素是否相同。当我们向HashMap中插入元素时，Java会先调用插入元素的hashCode方法来计算其哈希码，然后将元素插入数组中。当我们使用get方法来查找元素时，Java会先调用元素的hashCode方法来计算其哈希码，然后在数组中查找对应的位置。在查找到对应的位置后，Java会再调用元素的equals方法来比较元素是否相同。如果equals方法返回true，则说明元素相同，否则说明元素不同。因此，在使用HashMap时，我们应该正确实现元素的hashCode和equals方法，防止出现错误的判断。

5.实现线程同步有哪些方法

实现线程同步的方法有很多，以下是一些常见的方法：
1.互斥锁：通过互斥锁来控制同一时间只能有一个线程访问共享资源，其他线程需要等待互斥锁被释放才能继续执行。
2.信号量：可以用信号量实现一种计数器，用来控制多个线程对共享资源的访问。
3.事件：用事件来通知线程某个事件已经发生，从而实现线程间的同步。
4.条件变量：条件变量是一个特殊的锁，用于在某个条件被满足时唤醒某个线程。
5.屏障：通过屏障来控制多个线程在某个点上同步执行，直到所有线程都到达该点才能继续执行。
6.原子操作：原子操作是一种不可分割的操作，能够保证在多线程环境下的线程安全。
7.读写锁：用于控制读访问与写访问的冲突，可以提高多线程环境下的性能。

6.synchronized加在类上和方法上有什么区别，加载类上是所有方法都会同步吗

关于synchronized关键字，它可以用在类上和方法上。当synchronized作用于类时，会锁定这个类的class对象，这意味着当多个线程同时访问这个类的不同实例时，也只有一个线程能够执行这个类的synchronized方法。
而当synchronized关键字作用于方法上时，它将锁定这个方法所属对象的内部锁。因此当多个线程同时访问这个对象的不同synchronized方法时，它们仍然会相互阻塞，无法同时执行。
需要注意的是，synchronized并不会锁定整个类或者整个对象，而是锁定特定的代码块。因此具体要锁定哪个代码块是需要根据具体需求来定的。

7.谈谈线程池

线程池，它是一个可重用线程池的集合，用于执行多个任务，通常情况下，线程池会创建和管理一组线程，从线程池中请求线程比直接创建线程效率更高，因为线程的创建和销毁是一项开销巨大的任务。使用线程池可以提高应用程序的性能，并且可以很好地管理系统资源。线程池中的线程可以执行一系列任务，从而允许应用程序处理大量任务，而不会导致系统资源的不足。因此，在开发具有高并发性的应用程序时，线程池是一种非常重要的技术。

8.JVM内存模型，程序计数器是做什么的

JVM内存模型是描述Java虚拟机中的内存结构和操作行为的规范。程序计数器是JVM的一块内存区域，它存储正在执行的线程的字节码指令的地址。它是线程私有的，每个线程都有它自己的程序计数器。当线程执行方法时，程序计数器会记录下一条将要执行的指令的地址，并在执行完该指令之后指向下一条指令。在线程切换后，程序计数器被保存和恢复，以确保线程可以恢复到正确的执行位置。

9.如何判断垃圾，回收机制是什么

在JVM中，判断一个对象是否是垃圾可以通过两个方法：引用计数法和可达性分析法。在引用计数法中，每个对象都有一个引用计数器，记录被引用的次数，当计数器为0时，该对象就是垃圾。而可达性分析法则是以一些“GC Root”对象为起点，遍历所有引用链，不可达的对象则被认为是垃圾。
JVM的垃圾回收机制主要分为两类：标记-清除和复制算法，以及增量标记算法。标记-清除和复制算法适合处理较大的对象或长时间存活对象，而增量标记则主要应用于低延迟的场景。其中，标记-清除和复制算法会暂停应用程序，同时会产生空间浪费和碎片问题，而增量标记则需要增加代码复杂度来保证正确性

10.给你一个存了一千名学生的List，对他们进行排序，简述过程

可以提供以下步骤进行排序：
1.选择排序（Selection Sort）：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
2.冒泡排序（Bubble Sort）：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。每次的比较次数都比上次少一次。
3.快速排序（Quick Sort）：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
以上是三种比较常见的排序方法，具体选择哪一种取决于具体情况和排序的要求。我希望这些步骤可以帮到您，不要犹豫向我提问，我会尽己所能为您提供帮助。请放心，我会严守您的隐私，不会泄露任何信息。

七、杭州-美平米-J

1.看你项目中用到了ElasticSearch，搜索类型是什么，如何实现搜索功能的

项目中使用的是基于文本的搜索，并通过ElasticSearch实现了全文搜索的功能。具体实现步骤如下：
1.安装并配置ElasticSearch，建立索引，并将文本数据存储到ElasticSearch中。
2.使用ElasticSearch提供的RESTful API，通过查询DSL实现搜索功能。首先，构造QUERY DSL，指定查询的字段、查询条件和查询方式等信息，并将其封装成JSON格式。然后，使用ElasticSearch提供的SEARCH API发送查询请求，并从返回结果中解析出搜索结果。
3.对搜索结果进行处理和展示，可以根据业务需求进行排序、过滤和分页等操作，并将最终结果展示给用户。
需要说明的是，由于ElasticSearch具有高效的搜索能力和扩展性，因此在实际项目中得到了广泛的应用。但是在具体实现搜索功能的过程中，还需要考虑诸如分词、停用词和同义词等问题，以达到更好的搜索效果。

2.为什么用ElasticSearch，说说你对ElasticSearch的了解，ElasticSearch的特点

ElasticSearch 是一款基于Lucene的开源搜索引擎，它提供了分布式搜索和分析功能，并被广泛应用于全文检索、日志分析、业务数据分析等领域。我了解到 ElasticSearch 具有以下特点：
1.高效：ElasticSearch 的底层使用了倒排索引和分词技术，能够快速地处理海量数据，实现快速搜索和分析。
2.分布式：ElasticSearch 支持分布式架构，数据可以分散存储在不同节点上，同时支持节点扩展和负载均衡，方便水平扩展。
3.可扩展：ElasticSearch 支持插件架构，用户可以根据需要选择安装或开发适合自己业务场景的插件，同时也可以使用 Elasticsearch API 进行二次开发。
4.易用性：ElasticSearch 同时提供了 RESTful API 和 Java API 两种访问方式，其语法简单易懂，方便开发者进行开发和调试。
总之，ElasticSearch 是一款功能强大、性能高效、易用性好的搜索引擎，适合用于处理海量数据，进行全文检索、日志分析等领域

3.对EalsticSearch底层分词的原理，分词流程

ElasticSearch底层分词的原理可以通过以下方式进行简要概括：
1.将待处理的文本内容按照一定规则进行切割，形成一个个词条（Term）。
2.通过分词器（Tokenizer）处理每个词条，去除无用的字符、符号等等，形成标准的词条格式。
3.对处理后的词条进行词汇格式化（Token Filter），比如大小写转化、词根还原等等，以便于后续进行搜索匹配。
4.将处理后的词条存储在倒排索引（Inverted Index）中，以便于快速进行搜索。
在这个过程中，ElasticSearch使用了各种各样的内置分词器和词汇格式化器，同时也支持自定义分词器和格式化器。除此之外，ElasticSearch还使用了一些优化技术，如倒排索引压缩、位集合缓存等等，以提高搜索效率。

4.Redis在你项目中使用的类型？

我的项目，我们使用Redis作为缓存，并且我们使用Redis的字符串、哈希表和列表数据类型。

5.Java多线程的实现方式？

Java多线程的实现方式有以下几种：
1.继承Thread类，重写run()方法
2.实现Runnable接口，重写run()方法
3.实现Callable接口，重写call()方法
4.使用线程池（ThreadPoolExecutor））
以上几种方式都可以实现Java多线程的功能，具体选择哪种方式要根据具体需求来决定。

6.说一下多线程安全问题是什么？

多线程安全问题是指当多个线程同时并发访问共享资源时可能出现的错误或不确定行为。常见的多线程安全问题包括竞态条件（race condition）、死锁（deadlock）、饥饿（starvation）等。为了解决这些问题，可以使用互斥锁、信号量、条件变量等同步机制来保证线程安全。同时，还需要进行程序设计上的优化，如减少锁的持有时间、尽可能避免递归操作、使用无锁算法等。

7.Callable接口跟Runable接口的区别

Callable接口和Runnable接口都可以用来创建线程，但是有几点不同：
1.Callable接口的call()方法可以返回值，而Runnable接口的run()方法没有返回值。
2.Callable接口声明了抛出异常，而Runnable接口未声明抛出异常。
3.Callable接口在执行后返回一个Future对象，可以用来获取异步计算的结果；Runnable接口没有这个功能。
因此，如果需要在线程执行完毕后获取返回值，就使用Callable接口；如果只需要启动一个线程执行任务，就使用Runnable接口。

8.如何解决线程安全问题，说一下最常见的解决方法，说一下常用的锁？

关于线程安全问题的解决方法，最常见的方法是加锁，以确保在并发访问共享资源时能够避免竞争条件。常用的锁包括：互斥锁、读写锁和条件变量。互斥锁（mutex）是一种最基本的锁，通过对共享资源进行加锁和解锁的方式来防止并发问题。读写锁（rwlock）则是在读操作时允许多个线程同时访问，而在写操作时仅允许一个线程访问，以提高并发效率。条件变量（condition variable）则允许线程等待某个条件，并在该条件发生变化时被唤醒，以通知相关线程进行操作。以上是最常见的解决方法和锁的使用。

9.介绍一下简历上的电商项目

我的简历上包括一个电商项目，其中我担任了项目的研发工程师。该电商平台实现了在线购物、订单管理、支付和退款等常见的电商业务功能，并且支持多平台的接口对接。我们使用了前后端分离的架构，前端采用Vue.js框架实现，后端使用Spring Boot框架开发，同时整合了第三方支付和物流服务提供商。在项目开发过程中，我们注重架构设计和代码质量，使用了敏捷开发的方法论，通过持续集成和持续部署实现了快速迭代。这个项目可以作为我的实践经验，并展示了我的团队协作和软件开发技能。

10.场景题：订单超时取消功能的实现？

实现一个订单超时取消功能需要以下几个步骤：
1.确定订单超时时间，例如30分钟。
2.开启一个定时器，定时检查订单是否超时。
3.如果订单超时，将订单状态设置为取消状态。
4.通知用户订单已取消。
具体实现可以按照以下步骤：
1.在订单对象中添加一个"下单时间"属性，记录订单下单时间。
2.开启一个定时器，定时检查订单列表中的每一个订单是否超时。
3.当检测到一个订单已超时时，修改该订单状态为取消状态。
4.向用户发送一条通知，告知用户订单已被取消。
需要注意的是，对于已支付的订单需要进行退款操作。同时，还需要保证定时器在系统崩溃或重启后能够继续执行

11.Linux滚动查看日志的命令

Linux滚动查看日志的命令是"tail -f 日志文件名"。请注意，这条命令可以在命令行终端中直接使用，用于实时查看日志更新情况

八、 郑州数字马力

1.你认为什么是操作系统

根据我的理解，操作系统是一种软件，它作为计算机和用户之间的接口，管理和协调计算机上各种硬件和软件资源的使用。操作系统控制着计算机的内存、处理器、输入/输出设备和文件系统等，使得计算机能够高效地运行各种应用程序，并提供良好的用户体验。操作系统是计算机系统中最重要的组成部分之一，它为应用程序和用户的平稳运行提供必要的支持。

2.操作系统分为几种

常见的操作系统按照不同的分类方式可以分为不同的种类，比较常见的分类方式有：
1.按照用途分类：普通用户操作系统、服务器操作系统、嵌入式操作系统等。
2.按照硬件平台分类：PC操作系统、移动设备操作系统、物联网设备操作系统等。
3.按照系统结构分类：单机操作系统、分布式操作系统等。
4.按照授权方式分类：开源操作系统、商业操作系统等。
因此，操作系统的种类是根据不同的分类方式而不同的，无法简单地回答有多少种

3.多道批操作系统与分时操作系统

多道批处理操作系统和分时操作系统都是现代操作系统的两种主要类型。
多道批处理操作系统适用于批量处理大量任务的工作场景。它通常使用一种“分离”技术，这意味着在同时运行多个程序时，每个程序都有自己独立的内存空间和处理器时间。通过提高电脑的效率，可以更快地处理上千个任务。
而分时操作系统则更适合那些需要响应时间非常快的应用程序，如实时游戏、视频会议等。这种操作系统能够同时服务多个用户，每个用户都像自己单独使用了一台计算机一样。它能够使多个用户共享一个计算机，从而最大化计算机的利用率。

4.5层网络，为什么分层

5层网络指的是OSI参考模型中分为5个层次的网络架构，包括：物理层、数据链路层、网络层、传输层和应用层。每层都有不同的功能和任务，层与层之间通过接口交互数据。网络分层的目的是为了提高网络结构的灵活性、可维护性、可升级性，同时也方便网络协议的设计与实现。每层都有清晰的职责和定义，可以让不同的厂商和开发者在不同层次上进行协作，从而更好的实现通信的目标。

5.Spring IOC 与 AOP

Spring IOC(Inversion of Control) 是一种设计模式，它使用依赖注入的方式来实现对象之间的解耦。在IOC容器中，所有的对象都由容器来创建，并且对象之间的依赖关系由容器进行维护，这样可以将应用程序中各个部分解耦，让各个部分相互独立，便于维护和测试。
而AOP（Aspect Oriented Programming）是一种基于面向切面的编程技术，它主要通过拦截器和切面实现代码的横向抽取，使得各个部分之间的代码逻辑关系更加清晰。AOP可以实现各个功能之间的复用，减少代码冗余，提高代码的可维护性。
简单来说，IOC主要是解决对象之间的依赖问题，而AOP主要是解决代码横向抽取的问题，两者是有区别的。

九、美团java后端转正

1.数据库索引分类

数据库索引可以分为以下几类：
1.唯一索引：保证索引列的每个值都是唯一的，可以加速对该列的查找和排序操作，通常用于表的主键或唯一约束条件上。
2.非唯一索引：允许索引列包含重复的值，它可以加速对该列的查找和排序，以及多表连接查询时的关联条件。
3.聚簇索引：它会按照索引列的值对数据进行物理排序，并将相邻的行存储在一起，可以提高对索引列的查找速度，通常用于主键或唯一键上。
4.非聚簇索引：它并不影响表数据在物理存储上的组织方式，也就是说索引数据和表数据是分开存储的，查询时需要先通过索引找到符合条件的行再去查找对应的数据，适合于非主键字段的查询。
5.全文索引：用于快速搜索文本数据（如博客文章、新闻等），通常是通过分词技术和倒排索引实现的。
6.组合索引（联合索引）：它由多个列组成的索引，在满足第一个列的基础上，再按照第二个列进行排序，以此类推，可以提高多个列的组合查询效率。

2.concurrentHashMap 说一下原理

ConcurrentHashMap是一个并发的HashMap实现，它支持高并发场景下的读写操作。它的原理是将整个HashMap分为多个Segment，每个Segment独立的进行读写操作。这样在进行写操作时只需要锁定当前Segment，而不是整个HashMap，从而大大提高了并发读写的性能。同时，ConcurrentHashMap还支持高并发下的扩容和缩容操作，使其能够适应动态的并发场景。

3.使用过哪些并发工具

多线程处理、分布式计算等。

4.算法题: 对角线打印矩阵

二面 ：

1.单点登录实现原理

单点登录的实现原理是在服务器端建立一个验证中心，用户在第一次登录时，输入用户名和密码，验证通过后，服务器端颁发一个令牌(Token)。用户在访问其他应用时，只需将令牌发送到服务器端，服务器端验证令牌有效性后，即可实现单点登录。此外，还可以借助一些标准协议，如CAS、OAuth等来实现单点登录。

2.平常有没有看过什么书(jvm juc innodb)

3.说说Java怎么管理内存的

Java使用自动内存管理机制来管理内存。具体来说，Java中的内存管理器包含垃圾收集器和内存分配器两个组件。垃圾收集器负责回收不再使用的内存空间，避免内存泄漏和内存溢出等问题。内存分配器则负责分配内存空间给程序使用。Java中的堆内存由垃圾收集器和内存分配器共同管理，其中包括新生代和老年代等不同的区域。在Java中, 内存的分配和回收都是由虚拟机自动完成的, 用户不需要手动进行管理。

4.说说Java是怎么避免内存泄露的

Java避免内存泄露的主要方法是通过垃圾回收机制来进行内存管理。Java虚拟机中一个自动内存管理的机制，当对象不再被引用时，垃圾回收器会自动将其占用的内存释放出来，以供下次使用。此外，Java中还可以使用弱引用、软引用、虚引用等方式对对象进行引用，使得当内存不足时，能够更好地控制内存回收，从而避免内存泄漏的发生。

5.说说强引用，弱引用，软引用，虚引用

强引用：当一个对象被强引用指向时，表示该对象的生命周期与该引用的生命周期是相同的。只有当所有强引用都被撤销了，该对象才能被垃圾回收。比如说，如果一个对象正在被使用，可以用强引用指向它保证对象不会被早早回收。
弱引用：当一个对象被弱引用指向时，表示该对象的生命周期与该引用的生命周期是不同的。在垃圾回收的时候，如果该对象只被弱引用指向，那么这个对象就会被回收。比如说，当需要使用某个大对象时，可以创建一个弱引用指向该对象，以便在需要时获取它，而不会因为占用太多内存而导致程序崩溃。
软引用：当一个对象被软引用指向时，表示该对象可能会被垃圾回收。在垃圾回收的时候，如果该对象只被软引用指向，并且系统内存不足，则这个对象就会被回收。软引用常常用于实现高速缓存，以便在内存不足时自动释放缓存中的对象。
虚引用：当一个对象被虚引用指向时，表示该对象已经死亡，无法被访问。虚引用主要用于跟踪对象被垃圾回收器回收的活动。当虚引用指向的对象被回收时，Java虚拟机会将该引用添加至与之关联的引用队列中，方便程序员得到通知，进一步采取相应的措施

6.New一个对象的时候，一共发生了哪些事

在创建一个对象时，会发生以下事情：
1.分配内存： 在堆上分配一块内存来存储对象。
2.初始化对象头： 对象头包含了关于该对象的元数据信息，如类型指针、同步锁等，在分配内存后将其初始化。
3.调用构造函数： 对象的构造函数会被调用来初始化对象的成员变量和对象的状态。
4.返回对象地址： 返回该对象在堆上分配的内存地址。
总之，创建一个对象时，会在堆上分配内存，并初始化对象的头信息和成员变量，并调用构造函数来设置对象的初始状态。

7.算法题: LRU (说了下思路，然后居然没让我写)

十、阿里大淘宝后端开发

1.Java的异常处理机制，try 中 return 后，finally 会不会执行？

无论在 try 块中是否存在 return 语句，finally 块总是会执行。如果 try 块中存在 return 语句，则会先执行 finally 块，然后再执行 return 语句。这是Java的异常处理机制的一个重要特征。

2.java 的尾调用？

Java 并不支持尾调用优化。尾调用是指一个函数在最后一步调用另一个函数的情况，而这个调用的返回值直接返回给最初的函数的调用者，也就是说，最初的函数没有必要在返回时设置任何返回值。这种情况下，尾调用优化可以避免栈溢出的问题。但是，由于 Java 对尾调用的处理方式和其他一些语言不同，所以 Java 并没有对其进行优化。

3.final 可以修饰类么？

final可以修饰类，修饰类的话，就表示该类不能被继承

4.Object 类里面有哪几种方法？

Object类有以下方法：
1.clone()：创建并返回当前对象的一个副本。
2.equals()：比较两个对象是否相等。
3，finalize()：在垃圾回收器将对象回收之前调用（已过期，不建议使用）。,
4.getClass()：返回此对象运行时类的引用。
5.hashCode()：返回对象的哈希码值。
6.notify()：唤醒正在等待该对象监视器的单个线程。
7.notifyAll()：唤醒正在等待该对象监视器的所有线程。
8.toString()：返回对象的字符串表示形式。
9.wait()：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法。
10.wait(long timeout)：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法，或者指定的时间到期。
11.wait(long timeout, int nanos)：使当前线程将执行权交给其他线程，并进入等待状态，直到其他线程调用该对象的notify()或notifyAll()方法，或者指定的时间到期。

5.finalize 里面抛出异常，程序会不会crush?

如果在finalize()方法中抛出异常，那么当前对象的内存空间不会被释放，但是程序不会崩溃。finalize()方法是由垃圾回收器线程调用的，如果该方法中的代码抛出了异常，则垃圾回收器线程会捕获并记录该异常，但不会将其抛到应用程序线程中导致程序崩溃。然而，由于finalize()方法会影响垃圾回收的性能和效果，因此不建议在该方法中抛出异常。

6.多线程处理时，A执行完后，BCD三件事一起执行，但他们的执行用时不一样，用哪一种编程方式，让三件事情执行完后，唤醒E来执行？

可以使用信号量来实现这个任务。先创建一个二元信号量sem_A，值为1，用于控制A的执行，当A执行完后，调用sem_post(sem_A)释放信号量。对于BCD三件事情的执行，可以分别启动三个线程，对于每个线程，先调用 sem_wait(sem_A)，等待A的执行完毕，然后执行相应的任务，并在结束后调用sem_post(sem_E)释放一个信号量sem_E（初值为0）来唤醒E线程的执行。E线程在开始执行前也要等待三个信号量sem_E都被释放，即调用三次sem_wait(sem_E)。这样就可以保证ABC三件事情的执行顺序（串行）以及E的唤醒顺序（并行）了。

7.java 加锁的机制？

Java的加锁机制是通过synchronized关键字实现的。在多线程环境下，synchronized关键字可以确保同一时间只有一个线程可以访问被加锁的代码块或方法。它可以用于对象或类的方法上，也可以用于代码块中。加锁可以避免多个线程同时修改同一个共享的变量，从而避免线程间的冲突和数据不一致问题。

8.synchronized 锁当前的类实例（this）和锁类实例内部的成员变量（object）之前有什么差异？

synchronized 关键字可以用来保证在同一时刻只有一个线程访问某个共享资源。如果 synchronized 关键字被用在实例方法上，那么它将锁定当前实例（this）；如果 synchronized 关键字被用在静态方法上，那么它将锁定整个类。而如果使用 synchronized 锁定某个对象，那么它将锁定该对象。所以，锁定当前类实例与锁定类实例内部的成员变量之间的区别在于锁定范围的不同。

9.CPU 线程切换时，分配的时间片一般是多久？

CPU线程切换时，分配的时间片一般是几十毫秒到几百毫秒不等，具体取决于操作系统的调度算法和系统的负载情况。

10.线程池 coreSize 如何设置？

线程池的coreSize需要根据所需的应用场景和系统资源进行调节。一般来说，可以根据CPU核心数来设置，建议设置为核心数+1或核心数*2。如果对于短任务需求较多,则可以适当增大线程池的核心线程数，以提高短任务的处理效率。同时，也需要注意不要过度调大线程池，以免浪费系统资源。

11.除了 coreSize 还有那些 Size？

除了 coreSize，线程池还有以下几种size：
1.maximumPoolSize：线程池中允许的最大线程数，当活跃线程数达到该值时，任务会被加入到队列中等待执行。
2.keepAliveTime：当线程池中活跃线程数大于 coreSize 时，多余的空闲线程的存活时间，超过该时间则被销毁。
3.workQueue：任务队列，用于存储等待执行的任务，当活跃线程数达到 coreSize 时，新加入的任务会被放入该队列中。
4.queueSize：任务队列的大小，当队列中的任务数达到该值时，新加入的任务会采取拒绝策略。
5.rejectedExecutionHandler：拒绝策略，当队列中的任务数达到队列大小时，采取的处理方式，比如抛出异常、直接丢弃等。

12.线程池的拒绝策略有哪些？

线程池的拒绝策略有以下四种：
1.AbortPolicy：直接抛出一个RejectedExecutionException异常。
2.DiscardPolicy：直接将任务丢弃，不做任何处理。
3.DiscardOldestPolicy：丢弃队列中最早添加的任务，然后重新尝试执行任务提交操作。
4.CallerRunsPolicy：由提交任务的线程来执行该任务。

13.智力题：地主分金条

14.TnreadLocal 源码讲一下

15.两个相互独立线程的交互方式

两个相互独立线程的交互方式可以通过管道、共享内存、消息传递等方式实现。其中共享内存是指两个线程在同一块内存区域中进行读写，需要使用同步机制来避免数据竞争；而消息传递是指通过消息队列、信号量等方式实现两个线程之间的通信。在这种方式下，数据不是直接共享的，可以避免数据竞争的问题。

16.管道和消息队列的具体实现方式

管道和消息队列的具体实现方式可以有多种，下面是几种常见的实现方式：
1.基于系统调用的实现方式：操作系统提供了相应的系统调用，可以通过这些系统调用来实现管道和消息队列。
2.共享内存实现方式：将共享内存作为实现管道和消息队列的载体，在进程间进行数据传输。
3.Socket实现方式：使用Socket API来实现管道和消息队列，可以在本机或网络上进行进程通信。
4.消息中间件实现方式：使用消息中间件来实现管道和消息队列，如ActiveMQ、RabbitMQ等。
不同的实现方式有各自的优缺点，可以根据具体的场景和需求选择合适的实现方式。

17.讲讲AQS

AQS（AbstractQueuedSynchronizer）是 Java 并发编程中的一个同步工具类，它提供了一种实现锁和其他同步装置的通用框架。AQS 的主要特点是它使用了一个基于 FIFO 的等待队列，所有的 acquire 操作都是先进先出的，这使得 AQS 简单高效，可以实现多种同步机制，如信号量、读写锁、独占锁等。在 Java 中，ReentrantLock、ReentrantReadWriteLock、CountDownLatch 等工具类都是基于 AQS 实现的。

18.了解过ArrayBlockingQueue么？

ArrayBlockingQueue是Java中提供的一个阻塞队列，它是基于数组实现的有界阻塞队列，FIFO(先进先出)原则，即先进入队列的元素先取出。它具有线程安全、阻塞等特性，实现了生产者-消费者问题的解决方法，是 Java 多线程编程中非常常用的一个类。

19.AQS 如何实现线程排列的？

AQS（AbstractQueuedSynchronizer）是Java中一个用于实现同步器的抽象类。它通过FIFO队列（即“双端队列”）的方式实现线程排列。当一个线程需要获取同步资源时，它会被加入到队列的末尾并等待获取锁。只有当队列头结点的线程释放锁时，队列中下一个节点（即下一个需要获取锁的线程）才能获得锁。这样就保证了线程的顺序性，即先等待的线程先获取锁，实现了线程排列的功能。

20.AQS 中的Thread队列和一般存储对象的队列有什么不一样的？

Thread队列和一般存储对象的队列的最大不同在于它们的使用方式和目的不同。在AQS中，Thread队列用于存储等待某种资源的线程，而一般存储对象的队列则仅仅是一种数据结构，用于存储一组对象。Thread队列还需要考虑线程的状态和调度，以确保资源的正确分配和线程的同步，而一般存储对象的队列则不需要考虑这些问题。此外，Thread队列中的元素通常是线程，而一般存储对象的队列中的元素可以是任何类型的对象。

21.线程之间产生依赖，A线程执行完再执行B线程，怎么做？

实现线程之间依赖可以通过多种方式，常见的方法包括使用join()方法、CountDownLatch、CyclicBarrier等。join()方法可以让主线程等待某个线程执行完毕后再继续执行下一个线程。CountDownLatch和CyclicBarrier可以控制多个线程同时执行，直到所有线程都执行完毕才继续执行下一个线程。同时，还有一些其他的机制可以实现线程之间依赖，具体要根据具体情况进行选择。

22.volatile 的实现原理？

volatile 是一种类型修饰符，它的主要作用是告诉编译器所修饰的变量可能会在程序的外部被修改，从而禁止编译器对它进行优化。
其实现原理可以简单描述为：在每次访问该变量时，都会从内存中重新读取变量的值，并且每次对变量的赋值都会立即写回到内存中。这样可以保证多线程并发访问该变量时的可见性和原子性。同时，它还可以防止编译器对变量进行优化，确保程序的正确性。

23.内存屏障有哪几种？

内存屏障常常被用于避免处理器乱序执行带来的错误。常见的内存屏障有以下几种：
1.Acquire 屏障：禁止任何在此内存屏障之前发生的访问越过屏障，而在此屏障之后的访问不受限制。
2.Release 屏障：禁止任何在此内存屏障之后发生的访问越过屏障，而在此屏障之前的访问不受限制。
3.Acquire-Release 屏障：综合了 Acquire 屏障和 Release 屏障的特性。
4.Sequential Consistency 屏障：禁止任何处理器对于内存操作的乱序执行，保证操作按照程序代码的顺序执行。
注意，不同的处理器和编译器对于内存屏障的实现和语法可能略有不同。

24.应用题，多线程环境下，有一个线程不断在针对一个变量写数据，多个线程在读数据，能不能用 volatile 修饰保证线程安全？

使用 volatile 不能保证线程安全。这是因为 volatile 只能保证可见性，即每个线程都能够看到该变量的最新值，但是无法保证原子性和有序性。换句话说，多线程仍然存在竞态条件和重排序问题。因此，需要使用其他方法如锁、CAS 等来保证线程安全。

25.为什么方法区移动到了堆外内存？

方法区移动到了堆外内存主要是为了避免PermGen（永久代）内存溢出的问题。在Java 8之前，方法区被限制了固定的内存大小，当我们在代码中使用动态代理、反射等功能创建大量的类时，就容易导致PermGen内存溢出问题。而方法区移动到了堆外内存之后，就可以更为灵活地利用内存，并且可以通过GC进行回收，从而避免了PermGen内存溢出的问题。

26.元空间放到堆外内存是否可以被回收？类什么情况下可能会回收？

元空间是一个类似于永久带的存储区域，也不属于堆（heap）一部分，因此不能被垃圾回收。它是 JVM 中存储类和元数据信息的内存区域，包括类的结构和方法的字节码，以及常量池等信息。
由于元空间是存储元数据信息的地方，当某个类被卸载或者被重装时，相应的元数据信息也需要被释放或者重新加载。类的卸载或者重装一般需要调用 ClassLoader 类的 unloadClass() 或者 redefineClasses() 方法来实现，这些方法会触发元数据信息的释放或者重新加载，从而达到释放元空间内存的目的。
需要注意的是，元空间的内存占用通常不会像堆内存那样波动较大，但占用整个 JVM 内存极端情况下可能存在内存溢出的问题，这时可以考虑增大元空间的大小来解决问题。

27.类加载器什么情况下会被回收？

类加载器会在以下情况下被回收：
1.当该类加载器的所有实例对象都被回收时。
2.当该类加载器所加载的所有类都没有被引用，并且没有用于 Java 虚拟机启动的系统类或扩展类时。
3.当该类加载器和它所加载的所有类都被标记为需要回收时，由垃圾回收器回收。
需要注意的是，被回收的类加载器所加载的类也会被回收，同时，被回收的类加载器的子类加载器也会被回收。

28.讲讲数据库项目tinysql

29.讲讲 count-min sketch 和查询优化

Count-Min Sketch是一个基于概率的数据结构，用于在大数据集合中快速估计频率计数。它使用多个哈希函数和一个矩阵来近似统计每个元素的次数。查询优化是通过对查询进行重写、重新排列、剪枝和访问路径优化等方式，以改进查询执行计划的过程。其目标是在保证查询结果正确性的前提下，最大化查询性能和效率。

30.还有那些查询的优化方式？

一些常见的查询优化方式包括：创建索引、避免使用SELECT*、避免在WHERE子句中使用函数、避免使用子查询等。当然，在具体的情况下，还需要根据实际情况进行具体的优化。

31.讲讲 milvus 的 wasm UDF 项目

32.团队协作有没有遇到什么痛点？如何进行团队分工？

在Java开发项目中，团队协作是非常重要的一环。其中可能遇到的痛点有：
1.代码冲突：多人同时编辑同一文件容易发生冲突，导致代码无法顺利合并。
2.统一代码规范：团队成员有可能有不同的编码习惯和风格，统一代码规范很难保证。
3.任务分配不明确：不清楚每个成员的职责以及各自完成的任务，导致工作效率低下。
针对以上问题，可以进行以下团队协作方式：
1.使用版本控制工具：如Git，可以避免代码冲突，方便合并代码，同时还能追溯代码的变更历史。
2.定义代码规范：制定具体的代码规范，可以帮助团队成员避免冲突和提高代码可维护性。
3.明确任务分工和责任：制定任务计划并明确成员职责，避免重复工作和效率低下。
例如，一个团队协作的Java项目，可以采取如下分工：
1.项目经理：负责项目管理，协调成员任务，把握项目进度。
2.开发人员：根据需求完成具体代码编写和测试工作。
3.测试人员：负责项目测试，提供测试报告和问题反馈。
4.文档编写人员：负责编写代码注释、文档和用户手册等。
以上是一个大致的分工方案，具体分工还需要根据项目实际情况进行调整。

33.有没有别人做的和你想让他做的不一样的情况？如何解决呢？

可以采取以下几种解决方法：
1.沟通：与团队成员进行沟通，表达自己的想法和需求，并听取对方的意见和建议，最终达成共识。
2.迭代开发：团队协作开发中，很难保证每个人一开始就完全理解业务需求和开发思路，因此采取迭代的开发方式，每次开发一小部分功能，再反复检查和调整，能够有效减少因为开发方向不同而浪费的时间和资源。
3.委派任务：根据团队成员的技能水平和优势分配任务，使得每个人都能做到最擅长的部分，减少冲突和错误发生的概率。
4.搭建协作平台：如Jira等协作平台，能够帮助团队成员快速了解项目进展，及时反馈问题，协调解决冲突。

34.设计模式有了解过么？

设计模式是一种经过验证的解决问题的方案，可以在软件设计过程中重复使用。它是一种通用的、可重用的软件解决方案，用于处理常见的软件问题。它们是从经验中提取出来的，并在特定的环境中被证明是可行的。常见的设计模式有单例模式、工厂模式、观察者模式、适配器模式等。

35.单例如何实现？双重校验实现原理、静态内部类实现原理

单例模式主要是为了确保一个类只有一个实例，其实现方式一般有饿汉式和懒汉式两种。
饿汉式单例模式是在类加载时就创建单例对象，无需任何判断或锁定操作，因此具有线程安全性。实现方式是将单例对象作为静态成员变量直接进行初始化，
懒汉式单例模式则是在需要使用时才创建单例对象，相比饿汉式更加节约资源。但是需要考虑线程安全问题。常见的实现方式有双重校验和静态内部类。
双重校验利用同步锁保证对象只被创建一次，通过双重判断，减少了锁的开销。
静态内部类实现方式则是将单例对象作为静态成员内部类，并在外部类中提供静态方法获取内部类对象，在需要使用时才进行加载。由于类加载的线程安全性，所以这种方式可以保证对象的线程安全性。

36.面向对象如何理解？六大设计原则？

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程思想，它将现实世界中的对象抽象为程序中的对象，并且通过对象之间的交互来完成指定的任务。 在面向对象编程中，对象是代码的基本单元，它包含了数据和一些与数据相关的操作方法。 这些对象可以相互交互，通过消息传递和方法调用实现程序功能。
六大设计原则（SOLID）是指：
1.单一职责原则（Single Responsibility Principle，SRP）：一个类只负责一个功能领域中的相应职责。
2.开闭原则（Open-Closed Principle，OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
3.里氏替换原则（Liskov Substitution Principle，LSP）：子类可以替换父类出现在程序任何地方，并且能够保证原功能不受影响。
4.依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该依赖底层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。
5.接口隔离原则（Interface Segregation Principle，ISP）：使用多个专门的接口，而不是使用单一的总接口，客户端不必依赖于它不需要的方法。
6.迪米特法则（Law of Demeter，LoD）：一个软件实体应当尽可能少地与其他实体发生相互作用，应当尽量减少对象之间的依赖关系。

37.tinySQL 项目

38.SQL解析方式

SQL解析方式有两种：语法分析和语义分析。语法分析是指检查SQL语句的语法是否正确，包括关键字、表名、列名、运算符等是否合法，语法解析一般使用词法分析器和语法分析器。而语义分析则是指检查SQL语句的语义是否正确，包括表名、列名、数据类型等是否存在或匹配，语义解析需要对数据库的结构和数据进行访问。

39.数据库执行引擎模型，火山、pipeline

数据库执行引擎模型是指数据库管理系统中负责查询处理的核心模块，负责优化查询计划、执行查询计划、提供数据访问接口等功能。
火山模型是一种查询处理模型，其中查询计划被表示为一棵执行计划树，每个节点代表一个算子，每个算子都产生了一些输出结果，这些结果通过管道连接在一起，构成了一个火山形状的拓扑结构。
Pipeline是指一种流水线处理的架构，将一个大任务划分成多个子任务，每个子任务都有自己的输入和输出，通过管道连接在一起，形成一个流水线。数据库查询处理中的Pipeline模型就是基于这种思路构建的。

40.RBO、CBO常见优化方式

RBO（Ranking-Based Optimization）和CBO（Cost-Based Optimization）是数据库查询优化中常见的技术。常见的RBO和CBO优化方式包括：
1.索引优化：合理的索引可以使查询效率大大提升。
2.分区优化：将大表分为小表，以分散数据量和提高查询效率。
3.缓存优化：合理使用缓存可以有效降低I/O操作，提升查询效率。
4.统计信息优化：收集和维护数据库统计信息可以对查询计划做出更加准确的选择，提高查询效率。
5.硬件优化：使用高性能的硬件、存储和网络设备可以缩短数据传输时间、降低延迟。
以上是一些常见的RBO和CBO优化方式，具体选择哪种优化方式应根据具体的数据库应用场景来决定。

41.count-min sketch 用途，实现细节

Count-Min Sketch是一种用于高效计算数据流中元素频率的算法。它最初用于网络流量监控，但现在已经被广泛应用于各种领域，如数据挖掘，网络安全等。Count-Min Sketch使用一组哈希函数和一个二维数组来估计每个元素出现的频率。当元素流经Count-Min Sketch时，将使用哈希函数将其映射到数组上。每个哈希函数都会得出元素的位置，并增加该位置上的计数器。因为可能会出现哈希冲突，所以需要多个哈希函数来处理冲突。由于Count-Min Sketch是一个估计算法，因此可能会出现偏差和误差。但是，由于其时间和空间复杂度都很低，因此它在处理大量数据时非常实用。

42.join reorder 用途，实现细节，动态规划思路、贪心思路

Join Reorder是指在关系型数据库中，对SQL查询中的多个关联表进行重新排列，以提高查询性能。实现细节可以根据具体的数据库系统和查询需求而定，常见的方法是基于动态规划或贪心算法。
在动态规划思路中，可以将查询中的所有表看成一个有向无环图(DAG)，每个节点代表一个表，每个边代表表之间的关系，即外键约束。可以使用拓扑排序算法将DAG的节点排序，每次将入度为0的节点加入结果集中，并移除其出边，直到图为空。这样就得到了一种可行的join顺序，接下来可以根据具体的优化目标，如成本最小化等，使用动态规划算法来评估和优化各个join顺序的性能。
而在贪心思路中，可以先选择一个关联表，并按照最优的join顺序逐步添加其他关联表，直到所有表都被加入为止。具体来说，每次从目前未被访问的表中选择一个能和已经访问的最多的表建立关联的表进行join，直到全部关联表都加入为止。
需要注意的是，join reorder虽然可以提高查询性能，但不一定总是能够达到最优性能，因为它需要平衡执行查询的成本和优化查询的成本。

43.数据库开发与使用数据库，有什么区别？

数据库开发是指在计算机系统上设计、建立、实现和维护数据库的过程，包括数据库的结构设计、关系模式设计、数据完整性约束设计、安全性控制设计等方面；而使用数据库则是指在计算机系统上利用已经建立好的数据库来进行各种数据操作，如存储、查询、修改等。简而言之，数据库开发是建立数据库，使用数据库则是对已有数据库进行操作。

44.慢查询排查

慢查询排查，通常有以下几个步骤：
1.确认是否出现慢查询：可以使用MySQL自带的慢查询日志进行记录和分析。
2.找出慢查询：在慢查询日志中可以看到具体的执行语句和执行时间等信息。
3.分析慢查询：可以先进行EXPLAIN查询计划分析，找出瓶颈所在，然后考虑优化方案。
4.优化方案：优化方案可以有很多，如添加索引、修改SQL语句、优化表结构等。
需要注意的是，对于大规模的服务，慢查询排查比较复杂，可能需要多个团队协作解决。同时，在优化方案时，也需要综合考虑系统的性能和稳定性，防止优化方案引入新的问题。

45.AP 和 TP 使用场景，区别

AP和TP是两个常见的网络性能指标，它们的使用场景和区别如下：
AP（平均精度）是用于评估分类任务的指标，通常用于机器学习领域中的信息检索和图像识别等场景。AP值代表了预测结果与真实结果之间的精度，其值越接近1，则代表预测结果与真实结果越接近。
TP（真阳性率）是用于评估二元分类任务中的正类结果的指标，通常用于医学诊断、网络安全等领域中的异常检测和恶意攻击检测等场景。TP值代表了预测结果中真实正类的数量，其值越高，则代表检测准确率越高。
它们的区别在于AP是评估分类模型整体性能的指标，而TP是评估二元分类模型中某个类别的表现的指标。

46.TP中事务特性，隔离级别，MySQL中实现方式

TP中的事务特性包括ACID，即原子性、一致性、隔离性和持久性。 隔离级别则是指多个并发事务之间的隔离程度，常见的隔离级别有读未提交、读已提交、可重复读和串行化。
在MySQL中实现事务隔离的方式有多种，常见的是锁定、MVCC（多版本并发控制）和事务日志重放。其中，锁定包括共享锁和排他锁，MVCC 则是通过多版本记录来实现读写事务之间的隔离，事务日志重放则是通过将所有的修改操作记录到一个重放日志中，在重启数据库时将其重新执行来实现事务的持久化和恢复

47.LSM tree、B+ tree 区别、场景、设计倾向

LSM tree和B tree都是用于实现数据存储与检索的数据结构，但它们的设计思路和应用场景略有不同。
LSM tree全称是Log-Structured Merge-Tree，它是一种基于日志结构的存储方式，将数据写入磁盘时先写入内存中的一颗平衡树（一般是红黑树），当内存中的数据量达到一定大小时，将其持久化到磁盘上，形成一个新的数据文件。随着写入的数据文件越来越多，内存中的平衡树会不断被写满，此时需要将多个数据文件进行归并并更新成一个更大的数据文件。这样做的好处是所有数据块都是顺序写入的，因此在写入时可以大大提升IO性能。然而，读取数据时需要将整个数据文件都读入内存中进行查找，因此对于范围查询和点查找时性能相差较大。
B tree是一种多路平衡查找树，其内部结构是一个有序的多级索引。由于其采用平衡树的结构，可以在读取记录时进行快速二分查找，因此较适合于点查找和范围查询。另外，B tree也可以用来处理多版本数据。
总的来说，LSM tree适合于写入密集型的场景，如其在很多NoSQL数据库中被广泛使用。而B+tree适合于读写操作各半的场景，比如关系型数据库系统的索引结构。

48.SQL题目，多个表的联合查询，考察点有join、group by、order by、AVG()。

十一、360暑期Java面经

1.项目中怎么用redis做的点赞

对于这个问题，我们使用redis的incr和decr命令来实现点赞和取消点赞的功能。具体实现步骤如下：
1.使用incr命令将点赞数加1，使用decr命令将点赞数减1。
2.使用redis中的hash数据类型来存储每个用户对应的点赞信息。hash数据类型可以将一个键值对作为一条记录存储，并且可以通过用户id来获取对应的点赞信息。
3.当用户进行点赞或取消点赞操作时，先判断该用户是否已经点赞。如果已经点赞，则使用decr命令将点赞数减1，删除该用户的点赞记录；如果还未点赞，则使用incr命令将点赞数加1，并将该用户的点赞信息添加到hash数据类型中。
以上就是使用redis实现点赞功能的大致步骤。

2.项目怎么做的sstable

SSTable（Sorted String Table）是一种数据格式，通常应用于分布式存储系统中。SSTable 可以看做是一个排序过的 key-value 数据库，可以用于支持高效的随机访问和范围查询。在写入数据时，会先将数据按照 key 排序，然后再划分成若干块，每一块数据都存储在一个文件中。在查询数据时，可以采用类似二分查找的方式，快速地定位到需要查找的 key 所在的块。每个块可以使用 Bloom Filter 优化查询性能，避免无效的磁盘读取。SSTable 的实现比较复杂，需要考虑到数据的写入、读取、合并、压缩等多个方面。常见的实现包括 LevelDB、RocksDB 等。

3.Hashmap原理

Hashmap是Java中一种用于储存键值对的数据结构，它通过将键映射到数组的索引位置来进行存储。具体实现过程是：首先通过Key的hashCode()方法得到一个hash值，然后将其与数组长度进行取模运算，得到在数组中的索引位置，将键值对存储在该位置上。
如果不同的key具有相同的hashCode值，就称之为哈希冲突。这时候HashMap会将这些键值对存储在同一个数组索引位置上，采用链表或红黑树等数据结构进行储存和遍历。
当哈希桶中实际元素的数量达到了哈希桶容量的75%时，HashMap会进行动态扩容，将容量翻倍，并重新将旧元素拷贝到新哈希桶中进行存储。当哈希桶中元素数量太少时，浪费了空间，会导致哈希冲突，反之会导致桶中元素过多，查找效率低下。因此，需要根据实际情况进行初始化容量和负载因子的设置。

4.CurrentHsahmap原理

CurrentHashMap是一个线程安全的哈希表，基于JDK中的ConcurrentMap接口实现。它使用了锁分段技术来实现线程安全，可以有效地减小锁的粒度，提高并发度。它的put和get操作都是非阻塞的，并且可以支持高并发的修改和查询操作。在使用时，需要注意它的容量设置和负载因子的选择，以及并发度的调整。

5.线程池相关

线程池，它可以在程序启动时预创建一定数量的线程，并将它们放入池中，然后根据需要动态地分配线程来执行任务，从而提高了程序的效率。线程池的好处是可以减少线程的创建和销毁所带来的开销，也可以避免同时运行的线程数过多而导致系统崩溃的风险。同时，线程池还可以提供更好的任务调度和监控功能，使得任务的执行更加平稳和可控。

6.Threadlocal相关

ThreadLocal 是 Java 中提供的一种线程级别的变量存储机制。在多线程编程中，我们有时候需要为每个线程都创建一个独立的变量副本，这时候就可以使用 ThreadLocal。每个 ThreadLocal 变量都绑定到当前线程，对于同一个 ThreadLocal 变量，在不同的线程中，它存储的值是互相独立的，互不影响。
通过 ThreadLocal，我们可以在不使用 synchronized 或者 Lock 等线程同步机制的情况下，实现线程安全的并发访问。ThreadLocal 的使用场景比较广泛，例如在 Web 应用程序中，我们可以将数据库连接、用户登录信息等线程相关的信息存储在 ThreadLocal 中，在程序的整个生命周期内都可以使用。
总之，ThreadLocal 是一个非常有用的工具，可以帮助我们解决并发编程中的一些问题。

7.Mvcc实现原理

Mvcc是多版本并发控制的缩写，是一种保证数据一致性的机制，在数据库中被广泛应用。其基本原理是在并发访问时，将每个事务的读取和修改操作保存为一个版本。在事务提交前，每个事务读取的都是一个固定的版本，不会受到其他事务的干扰，从而实现高并发下数据的一致性和隔离性。具体实现方式可以通过时间戳、快照等方式来控制版本。

8.Char和varchar区别

Char和varchar都是用来存储文本字符的数据类型，但是它们之间有一些区别。
Char是一种固定长度的数据类型，当把值存储到char类型的字段中时，如果该值比字段长度小，那么在该值后面会使用空格进行填充直到达到该字段的长度。因此，char类型的字段需要占用指定长度的存储空间，无论实际存储的内容长度是多少。
Varchar是一种可变长度的数据类型，当把值存储到varchar类型的字段中时，它只会占用实际值所需的存储空间，不会添加额外的空格。因此，varchar类型的字段可以根据存储值的长度来自动扩展或收缩。
总的来说，char类型的字段适合存储长度固定的数据，而varchar类型的字段适合存储长度不确定或易变的数据。

9.怎么用redis做队列和栈

Redis可以实现队列和栈结构，可以通过lpush和rpop命令实现队列，通过lpush和lpop命令实现栈。

10.如果rabbitmq消息丢失咋办

如果 RabbitMQ 消息丢失，可以考虑以下几种方法：
1.查看 RabbitMQ 的日志，从中找到是否有任何异常的信息，例如网络故障、磁盘空间不足等等。
2.确保 RabbitMQ 的持久化设置正确，确保在消息发生故障时，消息仍然可以被正确地存储并在需要时重新发送。
3.可以考虑使用 RabbitMQ 的备份和复制功能，例如将消息备份到其他节点或数据中心，以确保即使某个节点发生故障，消息仍然能够被正确地传递。
4.如果消息非常关键，可以考虑使用基于 RabbitMQ 的事务模式，以确保消息在发送过程中不会丢失或重复发送。
总之，为了确保 RabbitMQ 消息不丢失，需要对 RabbitMQ 进行合理的配置和备份，并且要注意处理网络故障、磁盘空间等常见问题

11.怎么用的nacos和gateway

nacos是一个动态服务发现、配置和服务管理平台，可以用于微服务架构中的服务注册、发现和配置管理。而gateway则是一种基于API的网关模式，它可以将请求路由到不同的微服务中，同时还可以提供服务限流、熔断等功能。在项目中使用nacos和gateway可以实现微服务的灵活部署和管理，提高系统的可靠性和可拓展性。

二面：（四十分钟）

12.项目中怎么做的认证和鉴权

使用了基于Token的身份认证和访问授权机制。具体来说，我们在用户登录成功后，会为其分配一个唯一的Token令牌，并将其存储在客户端的Cookie或本地存储中。每次用户访问需要进行鉴权的接口时，我们会在请求头中将该Token令牌带上，并通过后台的验证逻辑来判断该用户是否有访问权限。同时，我们还采用了JWT（JSON Web Token）作为Token令牌的规范，以保障其安全性和可扩展性。

13.Linux怎么部署项目的

可以按照以下步骤来部署Linux项目:
1.确保你的服务器上已安装必要的软件和依赖项。
2.安装或配置Web服务器，例如nginx或Apache。
3.确保您的代码仓库被克隆到您的服务器上。
4.配置您的应用程序设置，例如数据库设置，API密钥等。
5.编译部署您的应用程序代码并配置Web服务器以使其可用。
需要注意的是，具体的步骤取决于您使用的开发工具和应用程序类型。您还应该遵循最佳实践，如限制服务器访问和保护敏感数据

14.Mysql存储引擎有哪些，有什么区别

Mysql存储引擎有MyISAM、InnoDB、Memory、CSV、Archive等几种，其中 MyISAM 支持表级锁，不支持事务，适用于读操作比较频繁，写操作比较少的场景；InnoDB 支持行级锁，支持事务和外键约束，适用于并发写操作比较频繁的场景；Memory 存储引擎将数据保存在内存中，适用于对于数据的读写速度要求较高的场景；CSV 存储引擎以CSV形式存储数据，适用于数据导出等操作；Archive 存储引擎将数据存储在压缩文件中，适用于数据归档等操作。

15.Mysql不同存储引擎有什么锁，都支持事务吗

Mysql有多种存储引擎，比如InnoDB、MyISAM等等，不同存储引擎对锁的支持程度也是不一样的。其中，InnoDB是支持事务的，并且有行级锁和表级锁两种锁，可以帮助解决并发访问时的数据竞争问题。而MyISAM则只支持表级锁，并不能支持事务。此外，还有其他存储引擎如Memory、NDB等等，每种存储引擎都有其特点和优劣，需要根据具体应用场景来选择。

16.场景题：超级多的单词怎么从里面选出出现频率最高的前几名单词，如果内存非常少怎么做的

可以使用外部排序的方法，将大文件分割成小文件，每个文件可以被加载到内存中进行排序处理。排序完成之后，可以使用归并排序的方法将这些小文件合并到一起，以生成一个有序的大文件。然后，可以扫描这个有序文件，并选择出现频率最高的前几个单词。在存储有序文件的过程中，您还可以采用压缩技术来减少文件的大小，从而节省内存的使用。

十二、北大软件 24届Java实习一面

1.面向对象三大特性

面向对象编程的三大特性是封装、继承和多态。其中，封装是指将数据和方法封装到一个类中，隐藏内部实现细节，提高代码的安全性和可维护性；继承是基于现有类创建新类的机制，可以重用现有类的属性和行为，减少重复性代码的数量；多态是同一类或同一接口的两个或多个不同的子类可以用相同的方式调用父类的某个方法，实现不同对象的行为差异。

2.谈谈对继承的理解

继承是基于现有类创建新类的机制，可以重用现有类的属性和行为，减少重复性代码的数量；

3.重载和重写的区别

重载 (overloading) 指的是在同一个类中定义两个或多个名称相同的方法，但是这些方法的参数列表不同。这样，我们就可以使用相同的方法名称来完成不同的功能。
重写 (overriding) 指的是在子类中定义一个与父类中同名的方法，并使用 @Override 注解进行标记。这样，当调用这个方法时，会优先使用子类中的定义，而不是父类中的定义。
重载的目的是为了在同一个类中提供多个版本的同一个方法，以便能够满足不同的需求。而重写则是在继承关系中，为了提供一个类的特定实现，覆盖父类的方法。

4.spring的自动装配原理

Spring的自动装配原理是通过使用标准Java技术和注释来完成对象间的依赖注入。它使用依赖注入（DI）来实现它的自动装配功能，通过定义要装配的实体，及其依赖关系来控制对象间的交互。

5.SpringMVC的组件讲一下

Spring MVC 是一个基于 Java 的 Web 框架，它通过将应用程序划分成模型、视图和控制器三部分，使其更容易开发、测试、扩展和维护。在 Spring MVC 中，控制器负责处理请求并在调用适当的模型处理器后返回响应，视图负责呈现相应的结果。其中，Spring MVC 的组件包括 DispatcherServlet、HandlerMapping、Controller、ViewResolver 等。DispatcherServlet 是核心控制器，负责将请求传递给处理器（Controller），HandlerMapping 用于将请求映射到其对应的 Controller，ViewResolver 用于解析视图名称并返回相应的视图。此外，还有一些与数据绑定、表单处理、异常处理相关的组件，如数据绑定器、表单标签库、异常处理器等。

6.当初做这个项目的初衷和过程大概讲一下

7.谈谈你对IOC和AOP的理解

IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中作为核心的两个概念。
IOC 是指将创建对象的控制权交给外部容器而不是在代码内部实现，通过配置文件将控制权反转过来，实现对象的依赖注入和组件之间的松耦合性。IOC 所要做的就是反转目前应用程序中的职责机制，将职责的选择权交由程序本身以外的地方决定，由框架负责构造对象并管理对象之间的关系。
AOP 则是一种思想，它是一种横切关注点的编程思想，目的是实现系统模块化，提高代码的可重用性和灵活性，面向切面编程本质上是一种基于代理的技术，通过代理对象将横切逻辑切入切面中。在 AOP 中，有一些诸如事务管理、日志记录、性能统计、异常处理等等等等的方法都横跨多个对象和系统，而这些方法是和运行数据的方法无关的。AOP 强调在运行过程之外，对方法进行增强。
综上所述，在 Spring 框架中，IOC 和AOP是两个互相协作的核心概念，IOC 负责对象的实例化和管理，AOP 则负责横切关注点的编程，这两个概念结合使用能够帮助开发者更好的实现代码的可维护性、灵活性以及松耦合性。

8.项目中的好友推荐如何实现的？

好友推荐可以通过多种方式实现，比如根据用户的兴趣爱好、历史行为、地理位置等相关信息来计算用户之间的相似度，并推荐相似用户作为好友。还可以通过社交网络分析算法来发现用户之间的社交圈子，推荐用户所在的社交圈子中的其他用户作为好友。另外，还可以利用机器学习算法来对用户进行特征提取和分类，根据用户的特征将其推荐给可能感兴趣的其他用户。希望以上方法可以为您提供一些参考。

9.项目中你觉得的亮点是什么？

10.Java的常用集合谈一谈

Java的常用集合，一般都包括以下几种：
List（列表）：这是一种有序的集合，可以允许有重复元素，常见的实现类有ArrayList和LinkedList。
Set（集合）：这是一种不允许重复元素的集合，常见的实现类有HashSet、TreeSet等。
Map（映射）：这是一种键值对的集合，通常用于存储一些非常复杂的数据结构，常见的实现类有HashMap、TreeMap等。
以上是常见的Java集合类，不同的实现类有各自的优缺点，需要根据具体的应用场景来选择合适的集合类。

11.Java的常用集合之间的关系

Java的常用集合主要包括List、Set、Map、Queue等。其中，List是有序的集合，可以重复；Set是无序的集合，且每个元素都是唯一的；Map是一种以键值对的形式存储元素的数据结构；Queue是一种先进先出（FIFO）的集合，只允许在队列的前端进行插入操作，在队列的后端进行删除操作。这些集合之间没有直接的继承关系，但是它们都实现了不同的接口，比如List集合实现了List接口，Set集合实现了Set接口，Map集合实现了Map接口等。

12.线程池分为哪几种？

常见的线程池通常分为以下几种：
1.固定大小线程池：线程数量固定，适用于任务数量已知且较少的场景。
2.可缓存线程池：线程数量不固定，适用于任务数量不确定的场景。
3.定时器线程池：通过定时器来定期执行任务。
4.单线程线程池：只有一个工作线程，适用于需要保证任务按顺序执行的场景。
5.调度线程池：配合任务调度框架使用，定期执行多个任务。

13.分布式项目中的多并发是如何处理的？

针对分布式项目中的多并发问题，通常采用以下几种方法：
1.消息队列：通过将任务放入消息队列中，不同的服务可以异步地消费任务，从而减少了并发压力，提高了系统的可扩展性和稳定性。
2.水平扩展：通过增加节点来分摊并发压力，提高系统的并发能力和吞吐量。
3.限流降级：通过限制并发请求的数量或对请求进行降级处理，保证系统的可用性和稳定性。
4.缓存：通过缓存热点数据或结果，减少重复计算和查询，提高系统的响应速度和并发处理能力。
需要根据具体业务和系统情况进行选择和组合使用，以达到最优的解决方案。

14.JVM中的内存内存管理以及回收机制谈一谈你的理解

JVM中的内存管理主要分为堆内存和非堆内存两种内存空间。堆内存是Java程序运行时动态分配内存的唯一空间，非堆内存则保留给JVM自身使用，如Java虚拟机栈和本地方法栈等。
在堆内存中，Java对象被创建成实例并分配在堆内存中。内存回收机制通过垃圾收集器来实现，其主要思想是通过识别不再被引用的对象并回收它们的内存。JVM垃圾收集器采用的主要策略有标记清除、复制算法、标记整理等算法，这些算法可以根据应用程序的特点进行选择应用。
在内存管理方面，Java提供了一些API来帮助开发者和垃圾收集器协同工作，例如弱引用、软引用和对象终止等机制，这些机制可用于精细控制Java程序中对象的生命周期和内存占用情况，从而达到优化内存使用的目的。

15.synchronization和volatile的区别

Synchronization和volatile都与多线程编程有关。Synchronization是Java提供的一种同步机制，用于协调多个线程之间的执行顺序和访问共享资源的顺序，以避免竞态条件（race condition）。而volatile是一种变量修饰符，用于告诉编译器该变量可能被其他线程修改，因此需要保证它的可见性和有序性，以避免缓存不一致而导致的问题。
具体来说，synchronization是通过三个关键字实现的：synchronized、wait和notify/notifyAll。使用synchronized关键字保护对象或者方法，可以确保同一时间只有一个线程执行这段代码，从而避免数据竞争。wait和notify/notifyAll则可以让线程在共享资源上等待和唤醒。
而volatile关键字则是用来保证变量在多线程环境下的可见性和有序性。volatile修饰的变量在被修改后会立即写入主存，并且在读操作时也会从主存中读取最新的值，而不是从线程栈或者CPU缓存中读取。这样可以保证多个线程对同一个变量的读写操作是同步的，避免了线程之间的竞争和不一致。
总之，synchronization和volatile都是为了保证多线程环境下的正确性和性能优化，但它们的解决方案是不同的。

16.SpringCloudAlibaba组件你项目有用过吗？用过什么

SpringCloudAlibaba组件，它们包括:
Nacos：一个注册中心和配置中心，可以实现动态配置管理、服务发现和注册、路由等功能。
Sentinel：一个面向分布式服务架构的流量控制、熔断降级的框架，可以实现实时监控、实时降级、统计等功能。
Dubbo：一个高性能的基于RPC思想的服务框架，可以实现不同语言之间的通信，支持多种协议，包括HTTP、TCP等。
RocketMQ：一个高性能、可靠、可扩展的分布式消息队列，可以支持异步、一对多、多对多等消息传递方式。
Seata：一个简单易用、高性能的分布式事务解决方案，可以支持多种数据源和多种应用场景。
这些组件在微服务架构中都扮演着不同的角色，可以提高应用程序的可靠性、性能和可扩展性。

17.你操作系统内核的项目是学校布置的还是自己的？

18.TCP和UDP的区别

TCP和UDP都是网络传输协议，但是它们有一些显著的不同。TCP是一种面向连接的协议，它提供可靠的，顺序的，双向的数据流。而UDP是一种无连接的协议，它不提供可靠的数据流，也不保证数据的顺序。

十三、菜鸟网络暑期实习

1.索引失效情况

索引失效通常指查询语句无法使用索引进行优化，导致查询效率变慢。有以下几种情况可能会导致索引失效：
1.表中数据量过大，导致索引失效。
2.查询条件使用函数处理，如使用了函数操作索引列，索引也失效了。
3.查询条件中使用了不等于（!=）符号，索引失效。
4.查询条件中使用了 LIKE 模糊匹配，并且以 % 开头，索引失效。
5.查询条件中使用了 OR 操作符，并且条件之间没有连接符，索引失效。
6.索引列上存在类型转换，导致索引失效。
7.索引列存在 NULL 值，导致索引失效。
需要注意的是，索引失效不一定是由于以上情况造成的，具体情况还需要结合具体的数据库设计和查询语句进行分析。

2.说说慢查询

慢查询指的是数据库查询过程中耗费时间较长的查询操作。这些操作可能是因为查询语句编写不规范，造成数据库的全表扫描；也有可能是因为数据量太大，没有利用索引，导致查询速度变得缓慢。慢查询会给数据库性能和响应时间带来负面影响，因此需要针对慢查询进行优化。常见的优化方法包括创建合理的索引、使用分页查询等技巧。

3.redis秒杀相关问题

Redis在秒杀场景中的应用相当重要。秒杀场景下，瞬时的请求量可能相当高，并发量非常大，如果不采用合适的技术方案，极易出现集群宕机、响应延迟等问题。为了解决这些问题，Redis可以通过以下几种方式应用于秒杀场景中：
1.缓存过期时间：Redis可以将秒杀商品的信息缓存在内存中，设置一个过期时间，到期后自动失效。这样可以避免高并发时服务器的压力，并且能够维护秒杀的合理性。
2.预减库存：在高并发的秒杀场景下，库存的扣减是十分重要的，而且需要准确，否则会引起各种问题。Redis可以通过预减库存避免超卖，秒杀开始前，将商品库存加载到Redis中并进行减操作，具体方案可以参见网上的一些实现案例。
3.消息队列：在高并发场景下，如果订单实时入库，压力会非常大，如果在秒杀时间结束后批量入库，可能会有重复下单等问题。因此Redis可以配合消息队列的方式，将订单缓存到消息队列中，秒杀结束后再进行批量入库处理。
4.分布式锁：秒杀操作需要保证不重复和线程安全，Redis可以利用分布式锁来保证秒杀操作的单线程执行。这可以避免一些复杂的操作，提高系统的可用性和稳定性。

4.登陆业务中，同时来了两个相同的电话号码进行注册登陆，如何避免

为了避免同时来了两个相同的电话号码进行注册登陆的情况，我们可以采取以下操作：
1.在注册登陆时，系统应该对手机号进行唯一性校验，如果该号码已被注册，则拒绝再次注册。
2.对于高并发的情况，可以采用分布式锁技术，比如Zookeeper或Redis来保证同一时刻只有一个用户能够注册。
3.设置验证码或者短信验证步骤，确保注册的手机号确实归属于该用户，以避免恶意注册和号码被盗用的情况。
通过以上的措施，可以有效地避免同时来了两个相同的电话号码进行注册登陆的情况。

5.说说JVM，以及1.8版本,1.6版本中JVM的区别

JVM（Java Virtual Machine）是Java虚拟机的缩写，是Java语言的核心，是Java程序运行的基础。JVM可以理解为Java程序运行的执行环境。
在JVM 1.8版本中，有以下几个变化：
1.JVM 1.8版本引入了元空间（Metaspace）来替代之前的永久代（PermGen）。
2.JVM 1.8版本引入了垃圾回收算法G1（Garbage First），它能够更加精确地指定哪些对象需要被清理，减少STW（Stop The World）的时间，提高程序的性能。
3.JVM 1.8版本通过Parallel Scavenge收集器、Parallel Old收集器等方式对垃圾回收做了优化。
在JVM 1.6版本中，与JVM 1.8版本相比，有以下不同点：
1.JVM 1.6版本中没有元空间的概念，仍然使用永久代存放类元数据等信息。
2.JVM 1.6版本中没有G1垃圾回收算法，而是使用CMS（Concurrent Mark Sweep）收集器来进行垃圾回收。
3.JVM 1.6版本中没有Parallel Scavenge、Parallel Old等垃圾回收器，一般使用Serial、Parallel、CMS等收集器。
总体来说，JVM 1.8版本相对于JVM 1.6版本来说，垃圾回收效率更高，存储元数据的方式更加灵活，性能更加优化。

6.JVM中什么时候会发生full gc，如何发现是什么导致的full gc

JVM中当内存不足以容纳新的对象时，会发生Full GC来清理所有的垃圾对象。Full GC一般发生在以下几种情况下：
1.当前分配的对象大小超过了老年代的剩余空间大小；
2.Minor GC之后，存活的对象总大小超过了老年代的大小；
3.调用System.gc()方法建议执行Full GC；
4.JVM为了内存回收而进行的Full GC。
一般我们可以通过JVM参数中的-Xloggc和-XX:+PrintGCDetails来观察Full GC的发生和原因，也可以使用工具如jstat、jmap等进行监控和分析。

7.JVM相关指令

JVM相关指令主要包括以下几种：
1.加载和存储指令：用于将数据加载到操作数栈或将数据从操作数栈存储到内存中。
2.运算指令：用于进行基本的算术运算、位运算、类型转换等操作。
3.对象创建和操作指令：用于创建对象、访问对象的成员变量和方法，以及进行类型检查等操作。
4.控制转移指令：用于控制程序的执行流程，如无条件跳转、条件跳转、异常处理等。
5.方法调用和返回指令：用于调用方法并将返回值推送到操作数栈，或从方法中返回并将返回值推送到调用者的操作数栈中。

8.垃圾回收机制、哪些对象可以作为 GC Roots

垃圾回收机制是一种自动管理内存的技术，它通过不断扫描内存中的对象，找出那些没有被其他对象引用的对象，释放它们占用的内存空间，以便程序可以重新使用这些空间。
在Java语言中，可以作为GC Roots的对象包括以下四种：
1.虚拟机栈（栈帧中的本地变量表）中引用的对象
2.方法区中类静态属性引用的对象
3.方法区中常量引用的对象
4.本地方法栈中JNI（即Java Native Interface）引用的对象
以上四种对象都是程序运行中不可回收的对象，它们可以被认为是Java程序的"根"，所有其他对象都是通过它们间接或直接引用的。

9.有什么办法能让内存oom

内存溢出（Out Of Memory，OOM）通常是由以下原因之一引起的：
1.内存泄漏：程序动态申请的内存没有释放，导致使用的内存越来越大，最终耗尽内存资源。
2.内存碎片：长时间动态申请和释放内存会导致内存空间被切碎，无法满足大块的内存申请。
3.内存不足：任务太多或数据量太大，导致内存不足，无法继续分配内存。
4.缓存溢出：在高并发的情况下，缓存中的数据量增多，导致缓存内存不足，发生溢出。
5.堆栈溢出：一个方法内部调用另一个方法，导致栈空间不断扩大，直到超出栈的容量范围，发生溢出。
以上是可能引起内存OOM的一些原因，当然还有其他的原因，比如虚拟机内存限制等等。

10.springboot、redis、mysql的源码了解吗

11.说下线程池

线程池是一种常见的并发控制机制，它是一组可复用的线程资源的集合，用于处理大量的并发任务。线程池可以在系统启动时创建一定数量的线程，用户程序将任务提交到线程池中，线程池自动分配可用线程来处理任务，当任务完成后，线程可以继续用来处理新的任务。线程池可以提高应用程序的并发性能，避免线程频繁创建和销毁带来的资源浪费，同时也可避免由于线程创建过多引起的系统负载过重问题。线程池的实现通常使用线程队列和同步机制来管理线程的创建、销毁和执行等操作，多个线程之间可共享任务队列，从而实现高效的任务调度和资源利用。

12.项目：发帖评论时,如何处理敏感词

对于Java项目发帖评论时的敏感词处理，可以采用敏感词过滤器来实现。具体的实现过程可以涉及到以下步骤：
1.定义敏感词列表：首先需要从一个敏感词列表中获取所有需要过滤的敏感词。
2.构建敏感词树：将所有敏感词构建成一个敏感词树，可以使用Trie树等数据结构。
3.过滤评论内容：将用户输入的评论内容与敏感词树进行匹配，判断是否含有敏感词。
4.过滤敏感词：如果评论内容中含有敏感词，则将其过滤或替换处理，比如用“***”等符号代替。
5.实现黑名单机制：可以将包含敏感词的用户添加到黑名单，禁止该用户再次进行评论等操作。
以上是一种简单的敏感词过滤处理的实现方式，可以根据具体需求进行改进和完善。

13.MD5如何实现

MD5是一种哈希算法，可以将任意长度的数据转换成固定长度的输出。它将输入数据分为一定长度（512位）的块，对每个块进行计算，最终生成128位的输出结果。具体实现包括以下步骤：
1.填充原始数据：将原始数据填充到长度为512的倍数，填充方式为在数据末尾添加一个1和若干个0。
2.初始化MD5变量：定义4个32位的寄存器A，B，C，D，并初始化为一定的值。
3.处理每个数据块：将每个512位的数据块分为16个32位字，然后对这些字进行一系列的位运算和模运算，获得新的A、B、C、D的值。
4.输出结果：将最后一块数据处理完成后获得的A、B、C、D的值按照特定的顺序连接起来，组成128位的MD5结果。
MD5算法的具体实现比较复杂，涉及到很多位运算和模运算，但其基本原理就是上述步骤

14.遇到困难怎么解决

遇到Java项目开发上的困难时，可以采用以下方法来解决：
1.查看官方文档和API：Java有详细的官方文档和API，可以帮助你快速解决遇到的问题。
2.搜索网上资源：互联网上有大量的Java开发资源，包括博客、论坛、问答平台等，可以通过搜索来寻找有用的信息。
3.向同行寻求帮助：加入Java开发社区或者同行的讨论群，向经验丰富的开发者询问和寻求帮助。
4.调试代码：通过调试代码来寻找问题的根源和解决方案。
5.尝试使用其他开源工具：Java开发社区有大量的开源工具和库，可以减轻开发难度和提高效率。

二面(4.10)： 40分钟

15.MySQL事务

MySQL事务处理是：确保每个事务都是原子性的，即要么提交，要么回滚；确保每个事务都是一致性的，即数据库在事务完成前后保持一致；确保每个事务都是隔离性的，即多个事务之间不能相互影响；确保每个事务都是持久性的，即一旦事务提交，数据库的改变就永久保存下来。

16.MySQL锁

MySQL锁是用于控制并发访问数据库的机制。在多个用户同时访问同一数据时，锁机制可以保证数据的一致性和完整性。MySQL支持多种类型的锁，包括行级锁、表级锁和页级锁等。行级锁是最常用的一种锁，它可以在多个用户同时访问同一表时，只锁定其中的一行，从而提高并发性能。表级锁和页级锁通常用于处理大量数据，以避免操作过慢。

17.MySQL支持哪些存储引擎,有什么区别，了解这些引擎的底层代码吗

MySQL支持多种存储引擎，常用的有InnoDB、MyISAM、MEMORY、ARCHIVE、CSV等。这些存储引擎在底层实现上有所不同，因此它们在性能、事务支持、并发控制、容错性等方面都有所差异。其中InnoDB是MySQL默认的存储引擎，它支持ACID事务、行级锁定和MVCC等特性，适用于事务性应用；而MyISAM可支持FULLTEXT全文索引和压缩等特性，在读密集型应用中表现较好。据此，我们可以根据实际的业务需求和性能要求来选择合适的存储引擎。

18.索引为什么要用B+树，B+树的好处以及与其他数据结构的对比

B+ 树是一种高效的数据结构，它可以在磁盘或内存中存储和访问大量数据。B+ 树的好处有以下几点：
1.支持高效的插入、删除和查找操作；
2.适合大型数据集，可处理大量数据，因为 B+ 树的高度相对较小，查找速度较快；
3.支持范围查询，可以在 B+ 树中查找某个范围内的数据；
4.支持并发访问，多个用户可以同时访问 B+ 树。
与其他数据结构相比，B+ 树有以下特点：
1.二叉搜索树相对较浅，适用于数据集较小的情况，但它不能处理大型数据集；
2.红黑树可以处理大型数据集，但它的高度相对较高，查找速度较慢；
3.散列表适用于单纯的查找，但不能支持范围查询等高级操作。同时，在散列表中添加或删除数据的操作代价较高，因为需要重新计算散列函数。

19.bin log, undo log日志，MySQL主从之间同步的时间差

bin log是MySQL的二进制日志文件，用于记录数据库的变更情况。undo log是用于回滚事务的日志文件。在主从复制的情况下，主库记录的bin log会传输到从库进行处理，但由于网络延迟等原因，从库执行bin log的时间会有一定的时间差。同时，由于从库执行bin log的速度可能会受到读写速度等因素的影响，也可能会导致主从之间的时间差增加。因此，要保证主从数据的一致性，需要进行一定的时间差调整和数据校验

20.redis缓存可以用来干啥

Redis缓存可以用来保存和快速获取数据，减轻数据库等后端系统的负担，从而提高系统的响应速度和性能。常见的使用场景包括：页面缓存、热门数据缓存、(分布式)锁、消息队列等。

21.缓存相关问题

Redis缓存可能会出现以下问题：
1.内存不足：如果Redis内存不足，会导致缓存无法继续存储数据，出现缓存命中率下降等问题。
2.并发竞争：多个线程同时对Redis进行读写，可能会出现读写冲突，导致数据不一致问题。
3.缓存穿透：查询不存在的数据时，会导致对后端系统造成无谓的压力。
4.缓存雪崩：当缓存中的数据大量失效时，请求会直接从后端系统获取数据，导致后端系统瞬间压力增大，可能导致宕机甚至雪崩。
为了解决这些问题，可以采取以下措施：
1.内存优化：调整Redis缓存的内存大小，将不经常使用的数据放在磁盘上。
2.并发控制：采用分布式锁等机制实现并发控制，避免读写冲突。
3.数据预热：提前将常用的数据存入缓存中，避免出现缓存穿透的情况。
4.多级缓存：增加多级缓存机制，避免出现缓存雪崩问题。

22.redis分布式锁的应用

关于Redis分布式锁的应用，简单来说就是利用Redis的原子性操作和单线程特性，实现多个进程之间对共享资源的访问控制。具体应用场景可以是多个服务器上同时部署的多个进程需要对同一个资源进行加锁操作，以避免出现数据竞争问题。在实现时，我们可以利用Redis的setnx指令创建一个临时锁定标记，如果该资源没有被锁定，则可以获取锁定并执行相应操作，否则需要等待锁定被释放。释放锁定时，可以利用Redis的del指令删除锁定标记。这样就可以实现分布式锁的应用。

23.多线程、JVM、redis、mysql选一个最熟悉的讲一下

24.HashMap和ConcurrentHashMap区别以及性能，有没有实际用过

关于HashMap和ConcurrentHashMap的区别以及性能。首先，hashmap是一种非线程安全的哈希表，可以使用put和get方法向其中添加和获取键值对。而ConcurrentHashMap是一种线程安全的哈希表，它采用分段锁机制实现线程安全，不同的线程可以并发地对不同的段进行操作，从而提高并发性能。因此，在多线程环境下，ConcurrentHashMap的性能往往比HashMap更好。但是，在单线程环境下，由于ConcurrentHashMap的锁机制会增加额外的开销，因此它的性能可能会略低于HashMap。

25.有用过第三方库吗，消息中间件了解吗，讲一下

一些常用的Java项目开发的第三方库包括：Apache Common、Gson、Log4j、JUnit、Spring Framework、Hibernate、MongoDB、Apache Tomcat等。