2023-04-20_面试题复盘笔记（253）

一、美团

1.类加载的机制

Java中的类加载器负责将类加载到JVM中，并在必要时解析和转换类文件。类加载器使用委托机制，先委托父类加载器尝试加载类，如果父类加载器无法加载，则由子类加载器加载。Java中有三种类加载器：Bootstrap ClassLoader、Extension ClassLoader和Application ClassLoader。其中Bootstrap ClassLoader是最顶层的类加载器，它负责加载Java的核心类库，是C++编写的，并不存在Java类，Extension ClassLoader是扩展类加载器，它加载Java的扩展类库，它的父类加载器是Bootstrap ClassLoader，Application ClassLoader是应用程序类加载器，它负责加载应用程序的类。

2.java.lang.string能不能被加载

答案是可以，因为java.lang.String类是Java语言中一个非常基础的类，它被JDK内置了，所以在Java应用程序中使用时无需显式引入它，JVM会自动加载它。

3.两个人写了相同的包名.类名 如何可以同时加载两个类，重写classloader 方法？

可以通过自定义类加载器，在其中实现重写classloader方法，使其可以同时加载两个同名的类。具体的实现需要重写findClass方法，通过在方法中区分不同的类加载器，然后分别加载不同版本的类。这样就可以实现在同一个运行环境中同时加载同名的两个类。

4.强软弱虚引用介绍一下

强引用是指被引用对象的内存空间不会被回收，只有当所有强引用都被解除之后，垃圾回收器才会回收该对象。软引用是一种比较弱的引用方式，如果一个对象只被软引用所引用，那么在垃圾回收时，如果内存足够，该对象会被保留在内存中，但如果内存不足，该对象将被回收。弱引用同样是一种较弱的引用方式，有一些场景下，例如缓存中，我们希望被缓存的对象在堆内存中不存在强引用，这就可以使用弱引用将其缓存起来。虚引用也是一种较弱的引用方式，但它并不会影响被引用对象的生命周期，其唯一作用是在被引用对象被回收时收到一个通知。

5.FullGC啥时候出现，频繁FullGC怎么做？性能监控和故障检测怎么做？

FullGC一般出现在Java虚拟机内存占用达到阈值时，触发垃圾回收机制。频繁FullGC的解决方法有以下几种：
1.增加可用内存，使得内存使用率下降，垃圾回收频率降低。
2.查找内存泄漏问题，避免产生大量无用对象，减少FullGC的发生。
3.调整垃圾回收参数（如-Xms、-Xmx、-Xmn等），提高GC效率。
性能监控和故障检测可以通过以下途径实现：
1.使用性能监控工具，如VisualVM、JProfiler等，进行实时监控，定期收集数据，及时发现问题。
2.利用日志记录GC信息、异常信息等，进行分析和排查问题。
3.使用开源框架，如ELK、Prometheus等，进行可视化监控和报警处理。

6.synchroned和lock的区别 ，synchroned底层怎么实现

Synchronized 和 Lock 都是 Java 中实现线程同步的方式，但是它们有一些区别。Lock 是一个接口，需要手动进行加锁和解锁操作，可以设置公平锁或非公平锁，并且可以被中断，提供更精细化的线程操作机制。而 synchronized 是 Java 语言内置的关键字，可以通过在方法或代码块前添加 synchronized 关键字来实现加锁和解锁操作，它是一种隐式锁，在使用时会自动进行加锁和解锁操作，不需要手动进行操作，但是只能使用非公平锁，且无法被中断。
Synchronized 底层实现是通过 monitorenter 和 monitorexit 指令来实现锁的获取和释放。在代码块或方法中添加 synchronized 关键字后，编译器会在字节码中添加指令来实现加锁和解锁。具体实现是通过对象头中的标志位来实现。当一个线程进入 synchronized 代码块时，它会尝试获取对象的锁，如果该锁没有被其他线程占用，则获取成功并将对象头的标志位置为“持有锁的线程标志”，该线程就可以执行代码块中的代码了；当线程执行完代码块后，会将锁释放，并将对象头中的标志位清空。如果另一个线程尝试获取该对象的锁，就会处于等待状态，直到该锁被释放。

7.进程的状态？什么时候会进入阻塞状态？

进程有三种状态：运行状态、就绪状态和阻塞状态。
1.就绪状态指的是进程已经准备好了要执行任务，只是还没有被CPU分配到运行状态。
2.运行状态指的是进程正在执行任务的状态。
3.阻塞状态指的是进程暂时无法执行任务，例如等待某个操作完成或等待输入，此时进程会被阻塞。
一个进程会进入阻塞状态的情况有很多，比如等待 I/O 操作、等待某个进程的信号或等待资源等。当一个进程需要等待一些操作完成或获得某些资源时，它就会进入阻塞状态。在这种情况下，进程会被暂停执行，直到等待的资源就绪后才能继续执行。

8. 字节流和字符流区别。

字节流和字符流的区别在于它们处理的数据类型不同。字节流以字节为单位读写数据，适用于处理二进制数据或者文本数据中的字节流。而字符流则以字符为单位读写数据，适用于处理文本数据中的字符流，可以自动处理字符编码转换的问题。另外，字节流是底层输入输出流，而字符流是在字节流基础上的高层输入输出流。

9.AQS原理

AQS（AbstractQueuedSynchronizer）是Java中基础类库提供的一个用于实现同步器的框架。它是实现锁（Lock）和其他同步工具（例如Semaphore、CountDownLatch等）的基础组件，也是ConcurrentHashMap、ThreadPoolExecutor等并发工具的关键实现部分。AQS基于FIFO的队列等待机制，提供了比传统的synchronized关键字实现更加高效和灵活的同步机制。其本质是一个抽象的队列同步器，子类可以实现自己的同步语义。

10.ThreadLocal 底层实现原理，为什么内存泄漏，

ThreadLocal 是一个线程内部的局部变量，它可以保证在同一个线程内部，每个线程拥有自己的独立的变量副本。它的底层实现原理是用一个 ThreadLocalMap 对象来存储每个线程的变量副本，这个 ThreadLocalMap 对象的 key 是 ThreadLocal 对象本身，value 是该线程内部的变量副本。当一个线程结束时，它的 ThreadLocalMap 对象会被回收，从而避免了内存泄漏的问题。
但是，如果我们自己定义的变量是一个强引用类型，并且在 ThreadLocal 中被设置了值并且没有被主动清除，在线程池的复用过程中，即使线程结束，对应的对象的强引用也不会被释放，因此会导致内存泄漏。为了避免这种情况，我们应该在使用完 ThreadLocal 中的变量后，及时调用 remove 方法将其清除，这样即使线程根据 ThreadLocalMap 对象被回收，对应的对象也会被垃圾回收器回收，避免了内存泄漏问题。

11.两个机器如何实现ThreadLocal信息共享

实现ThreadLocal信息共享可以使用InheritableThreadLocal类，它可以在线程池之间传递ThreadLocal变量值。另外，也可以使用共享线程池或者自定义线程池来实现跨线程池共享ThreadLocal变量。需要注意的是，在实现该功能时，需要对线程池的使用进行仔细的规划和管理，确保线程池资源的合理分配和使用，避免线程安全问题的发生。

12.为什么重写equals、hashcode 方法

重写equals和hashcode方法的主要目的是在对Java对象进行比较时确保可靠性和正确性。equals方法是用于比较两个Java对象是否相等的方法，而hashcode方法则返回一个Java对象的哈希码，用于在集合中寻找该对象的位置。如果没有正确重写这些方法，可能会导致比较和哈希不正确，从而导致不正确的行为或错误的结果。所以，重写equals和hashcode方法是很重要的

13.BIO NIO AIO

BIO、NIO 和 AIO 都是 Java 中 IO 的实现方式。
BIO（Blocking IO）是一种同步阻塞 IO，即在进行 IO 操作时，如果没有数据可读或可写就一直阻塞等待，直到有数据可读或可写。
NIO（Non-blocking IO）是一种同步非阻塞 IO，即在进行 IO 操作时，如果没有数据可读或可写就立即返回，不会一直阻塞等待，这样可以提高 IO 的效率。
AIO（Asynchronous IO）是一种异步非阻塞 IO，在进行 IO 操作时，不需要等待数据的返回，可以继续进行其他操作。当数据返回时，系统会通知程序进行处理。这种方式可以进一步提高 IO 的效率。

14.说出常见容器的名称还有各自的继承关系

常见的容器包括：vector、deque、list、set、map。它们的继承关系如下：
vector、deque、list 都属于 STL 中 Sequence（序列）容器的范畴，其中 vector 和 deque 都属于线性表，而 list 属于链表。
set、map 都属于关联容器，set 中的元素按照某个关键字排列，而 map 中的元素则是按照 key-value 的形式存储。

15.HashMap为啥扩容因子是0.75

HashMap的扩容因子是0.75是为了在保障空间利用率的同时避免过多的哈希冲突，提高查询效率。在哈希表存储元素时，会根据哈希值将元素存储到对应的桶中，如果哈希冲突过多，桶内就会形成一个链表或树结构，查询时就需要遍历这些元素。扩容因子为0.75时，可以较好地平衡空间利用率和哈希冲突的数量，使得查询效率得到优化。

16.为啥不能在for iterator 里面修改集合？元素会怎么样？迭代器设计模式，底层怎么实现的？

在 for iterator 循环中修改集合会导致集合的结构发生变化，可能会导致未知的错误发生。具体来说，如果你添加或删除集合中的元素，迭代器可能无法准确地指向下一个元素，导致编程错误。如果你确实需要在循环中修改集合，可以使用 while 循环或普通for循环代替 for iterator 循环来解决问题。
迭代器设计模式是一种行为型设计模式，其目的是提供一种统一的遍历集合元素的方式，不暴露集合实现的细节。
底层实现通常是将集合的遍历过程抽象成一个迭代器对象，该对象负责遍历集合元素并提供相应的访问方法。迭代器对象通常包含两个核心方法：next() 用于获取下一个元素，hasNext() 用于判断是否还有下一个元素可遍历。
在实现迭代器对象时，可以使用一个内部类来实现具体的迭代器。该内部类需要维护一个指向当前遍历元素的指针，并实现 next() 和 hasNext() 方法。
集合类则需要实现一个获取迭代器对象的方法，返回内部实现的迭代器对象即可。这样，客户端使用迭代器遍历集合时，无需关心集合的底层实现，只需要通过迭代器对象访问集合元素即可。
总之，迭代器设计模式通过将集合的遍历从集合类中分离出来，提高了代码重用性和灵活性。

17.Redis

Redis是一个开源的、高性能的键值对存储系统，它支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等。Redis具有高速读写、支持数据持久化、支持事务、发布/订阅、Lua脚本等特性，可以用于缓存、消息队列、排行榜、实时统计计数、分布式锁等场景。使用Redis需要先安装Redis并启动服务，然后通过客户端连接Redis并执行相关命令，如设置和获取数据、发布和订阅消息等。

18.过期策略

Redis过期策略有两种：
1.定期删除：Redis会每隔一段时间，检查一些设置了过期时间的key，将过期的key删除。这种方式会占用一定的CPU时间，但是可以确保过期的key及时删除。
2.惰性删除：Redis会在访问某个key时，检查一下这个key是否过期，如果过期了就删除。这种方式不需要占用CPU时间，但是不能确保过期的key及时删除。
根据实际情况选择适合的过期策略。

19.缓存击穿、缓存穿透、缓存雪崩

缓存击穿、缓存穿透、缓存雪崩都是常见的缓存问题。
1.缓存击穿指的是在缓存未命中的情况下，大量请求同时访问数据库，导致数据库压力过大的情况。这种情况可以通过添加互斥锁或者分布式锁来解决。
2.缓存穿透指的是在缓存未命中的情况下，大量请求同时访问数据库，但是数据库中不存在该数据的情况。这种情况可以通过在缓存中增加空对象或者布隆过滤器来缓解。
3.缓存雪崩指的是在缓存中大量的缓存数据同时失效，导致请求都要访问数据库的情况。这种情况可以通过设置缓存过期时间的随机性来解决，也可以采用分布式缓存的方式来减轻压力。

20.从浏览器输入URL到返回结果这个过程都发生了什么

这个过程可以大概分为以下几个步骤：
1.用户在浏览器中输入URL。
2.浏览器向DNS服务器请求解析URL中的域名。
3.DNS服务器将URL中的域名解析为对应的IP地址，并将IP地址返回给浏览器。
4.浏览器使用TCP协议向该IP地址发起请求。
5.服务器收到请求后，对请求进行处理，返回相应的数据。
6.浏览器接收到数据后，对数据进行解析和渲染，将页面或者资源展示给用户。

21.TCP报文结构

TCP报文结构通常包含了以下几个部分：TCP头部和数据部分。TCP头部包含了源端口号、目的端口号、序列号、确认号、窗口大小、校验和等重要字段，其中序列号和确认号用于实现TCP可靠传输机制。数据部分则包含了应用层数据。TCP报文结构可以用于实现面向连接的可靠数据传输，广泛应用于互联网中的各种应用。

22.HTTP报文结构

HTTP报文包括请求报文和响应报文两种类型。每种类型的报文又分为首部和主体两部分。请求行是请求报文的第一行，由请求方法、请求URI和HTTP协议版本号组成。响应行是响应报文的第一行，由HTTP协议版本号、状态码和状态码的原因短语组成。请求头部和响应头部包含了各种HTTP选项和数据信息。主体部分则可以携带HTTP请求或响应的实际数据。

23.GET和POST？幂等性

GET和POST是两种常见的HTTP请求方法。GET用于从服务器获取资源，而POST用于向服务器提交数据。GET请求将数据附加在URL的查询字符串中，而POST请求将数据包含在请求体中。GET请求对数据大小和安全性有限制，而POST请求可以传输大量数据且更加安全。
幂等性是指对同一操作的多次执行所产生的影响是相同的，即不会产生重复的操作结果。在计算机程序中，幂等性通常用于保证操作的正确性和稳定性。例如，HTTP中的幂等性指令能够让同一请求在重试时不会产生重复的操作结果，从而保证数据的正确性。

24.说一下网络状态码

网络状态码是客户端与服务器之间通信时，服务器返回给客户端的一种标识状态的数字代码。常见的状态码有200表示成功，404表示请求的资源不存在，500表示服务器内部错误等等。网络状态码是进行网络通信时重要的参考指标，能够反映出网络的稳定性和可靠性。

25.消息队列

当开发一个大型系统时，通常需要处理许多请求。这时候，使用消息队列可以有效的异步处理请求。消息队列可以将请求分发到不同的服务中，确保服务独立运行，避免因为某一服务崩溃拖垮整个系统。在一个分布式的应用中，消息队列可以协调不同服务之间的通信，解决异步通信的问题。同时，使用消息队列可以实现生产者和消费者的解耦，提升系统的伸缩性和可维护性。

26.消息队列怎么解决重复消费、消息丢失问题

常见的解决方案有两种：
1.消息去重
在消费端在处理一条消息之前，先通过存储系统（例如 Redis）判断之前是否处理过该条消息。如果处理过，则直接跳过；如果未处理，则将消息标记为已处理，并处理该条消息。
2.确认机制
在消费端处理完一条消息后，需要向消息队列发送确认信息，告诉消息队列该条消息已经被成功消费。如果消息队列在一定时间内收到了确认信息，则认为该条消息已经被成功消费。如果在一定时间内未收到确认信息，则认为该条消息消费失败，进而触发重试机制。
其中，解决消息丢失问题需要使用持久化消息队列。

27.mysql

MySQL是一种关系型数据库管理系统，它是一种开源的软件，可以在多种操作系统上运行。
MySQL的特点是开源、可定制，性能稳定优越、易学易用、可以自定义函数等。
MySQL主要用于存储数据并提供数据查询服务，可以将数据存储在表格中，方便查询和管理。
MySQL的使用方法包括安装、配置、创建数据库和表格、插入数据、修改数据、删除数据、查询数据等操作。

28.索引种类

常见的索引种类有唯一索引、主键索引、普通索引、全文索引、外键索引等。

29.算法题 大数相加

二、微众银行-社招

1.jvm启动参数

常见的 JVM 启动参数包括：-Xms 和 -Xmx 设置 Java 堆的初始大小和最大大小；-XX:PermSize 和 -XX:MaxPermSize 设置持久代的初始大小和最大大小（只适用于 JDK 8 或更早版本）；-XX:NewRatio、-XX:SurvivorRatio 和 -XX:MaxTenuringThreshold 设置新生代、幸存区以及晋升阈值的比率等等。这些参数可以通过命令行或者在启动脚本中设置。

2.自定义注解，如何实现非空判断

使用 Java 的元注解 @NotNull 或者 @NonNull 等，将其应用到方法的参数或返回值上，表示该参数或返回值不能为空。在方法中可以使用这些注解进行非空判断，以确保参数或返回值的合法性。

3.bean生命周期

Bean的生命周期是指从Bean的创建、初始化、使用，到最后的销毁的整个过程。它包括在Spring容器中创建一个Bean实例，填充属性，调用一些初始化方法，使用Bean，以及在容器关闭时调用销毁方法等阶段。在这个过程中，Spring提供了多个扩展点，让开发者可以在合适的时机参与到Bean的生命周期中，完成更多自定义的操作。

4.Spring IOC 和 AOP

Spring IOC（Inversion of Control，控制反转）是一种设计模式，它将对象创建与对象之间的依赖关系的处理分离，使得系统更加灵活、可扩展。在Spring框架中，IOC容器就是实现IOC的核心，它负责管理对象的生命周期和对象之间的依赖关系。
Spring AOP（Aspect Oriented Programming，面向切面编程）是一种编程思想和技术，可以在不修改原有代码的情况下，通过对程序中的某些特定点进行“切面”的操作，从而插入新的逻辑和行为，以实现程序的解耦和增强。在Spring框架中，AOP是通过对方法进行拦截实现的，可以应用于事务管理、日志记录、性能监控等方面。

5.jdk和cglib，静态代理和动态代理差别

JDK和CGLIB都可以实现代理模式，但是它们实现的代理类型不同。JDK实现的代理是基于接口的，也称为接口代理。JDK通过反射机制动态生成代理类，该代理类实现了接口中的所有方法，并将方法调用委托给了被代理的对象。而CGLIB实现的代理是基于类的，也称为子类代理。CGLIB通过继承被代理类，动态生成一个子类，并重写其中的方法来实现代理。相比于JDK代理，CGLIB代理的效率更高，但是被代理的类必须有默认构造方法并且不能被final修饰
静态代理和动态代理都是代理模式的实现方式。静态代理是在编译时确定代理类和被代理对象的关系，而动态代理是在运行时通过反射等机制动态地生成代理类来代理目标对象。
具体来说，静态代理需要手动编写代理类，同时需要明确被代理对象的接口或实现类，实现代理类与被代理对象之间的交互。而动态代理则可以通过Java自带的Proxy类以及InvocationHandler接口等实现动态生成代理类，避免了手动编写代理类的繁琐操作。因此，动态代理更具有灵活性和扩展性。
总的来说，静态代理适合于在项目初期使用，而动态代理适于后期扩展和优化。

6.spring传播行为和隔离级别

Spring的传播行为(propagation behavior)用于定义一个事务如何进行传播，对于在事务范围内的嵌套事务，定义了如何传播目前事务的属性，Spring事务的传播行为共有7种，包括:
1.PROPAGATION_REQUIRED (默认)：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。
2.PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务的方式执行。
3.PROPAGATION_MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。
4.PROPAGATION_REQUIRES_NEW：新建一个全新的事务，并且暂停当前事务(如果存在)。
5.PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
6.PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
7.PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行，如果当前没有事务，则执行与PROPAGATION_REQUIRED相同的操作。
另外，Spring的隔离级别(isolation level)用于定义多个事务之间的相互影响程度，定义了多个事务如何相互隔离，Spring事务的隔离级别共有4种，包括:
1.ISOLATION_DEFAULT：使用底层数据库的默认隔离级别。
2.ISOLATION_READ_UNCOMMITTED：最低的隔离级别，允许脏读、不可重复读和幻读的发生。
3.ISOLATION_READ_COMMITTED：在同一个事务内，不会出现脏读，但是可能会出现不可重复读和幻读。
4.ISOLATION_REPEATABLE_READ：在同一个事务内，不会出现脏读和不可重复读，但是可能会出现幻读。
5.ISOLATION_SERIALIZABLE：将事务串行化，避免了脏读、不可重复读、幻读的发生，但是并发性能非常低。

7.mysql间隙锁

MySQL的间隙锁指的是在一个范围内的不存在记录的“间隙”（即上一个记录和下一个记录之间的空隙），为了防止其他并发事务在该范围内插入记录，MySQL会在间隙上自动加上间隙锁。
这种锁主要用于解决幻读问题，即并发事务在某个范围内查询时，会出现在查询范围内新增或删除记录的情况，从而导致结果集不一致。使用间隙锁可以有效地避免这种情况的发生，但也会增加系统的开销和死锁的概率。

8.innodb和myisam区别

InnoDB和MyISAM是MySQL数据库的两种不同的存储引擎。InnoDB是一种支持事务、行级锁定和外键的高级存储引擎，而MyISAM则是一种不支持事务和行级锁定的存储引擎。
具体而言，InnoDB对事务的支持是通过ACID（原子性、一致性、隔离性和持久性）属性来实现的，它支持多版本并发控制（MVCC）并可以在高并发环境下保证数据的完整性和一致性。而MyISAM则不支持事务和MVCC，因此在高并发环境下可能会出现数据不一致的情况。
在性能方面，MyISAM对于读取操作的性能比较优秀，也比较适合于一些只读的场景，而InnoDB则更加适合于高并发的写入场景。此外，InnoDB支持外键和自动增长的主键，而MyISAM则不支持。
总之，选择InnoDB还是MyISAM取决于具体的业务场景和需求。如果需要支持事务、外键和高并发的写入场景，那么InnoDB可能更加适合；而如果是一些只读的场景，那么MyISAM则可能性能更好一些

9.ApplicationContext是干嘛的

ApplicationContext 是一个接口，它代表应用程序的上下文，通常在应用程序初始化时创建，它的主要作用是提供常见的应用程序功能，例如访问资源、管理bean和处理消息等。此外，ApplicationContext 还为应用程序提供了许多便利功能，例如管理应用程序生命周期、实现国际化和本地化以及实现安全等。它是 Spring 框架的核心组件之一，被广泛应用于 Java Web 开发、企业级应用程序和分布式系统中。

10.未命中索引怎么办

如果在MySQL中发现查询语句未命中索引，可以考虑以下几个方法：
1.分析查询语句，确认是否可以优化。有些情况下，查询本身就不够优化，需要对查询进行优化。
2.使用SHOW INDEXES命令来查看表中的索引信息，并确认是否存在适当的索引。
3.如果索引不存在，可以使用CREATE INDEX命令来创建索引。
4.如果索引存在但没有被使用，可以使用FORCE INDEX命令来强制使用该索引。
5.如果索引已经被使用，可以考虑对索引进行优化，例如使用COMPUTED COLUMN、PARTITION等技术来优化索引。
综上所述，当MySQL中未命中索引时，需要对查询进行优化，并确认是否存在适当的索引，如索引不存在，则需要创建索引，如索引已存在则需要优化索引以提高查询效率。

11.Null和""在数据库区别：

在数据库中，Null表示一个字段没有被赋值，而"“表示一个字段被赋为空字符串。Null和”“在含义上是不同的，Null表示未知的值，而”"表示一个确定的空值。在查询语句中，可以使用IS NULL或IS NOT NULL来检查一个字段是否为空值，或者使用WHERE字段名称=’ '来检查一个字段是否为空字符串。

12.servlet, filter, listener是干嘛的

Servlet、Filter和Listener都是Java Web中的重要组件，它们分别承担着不同的功能：
1.Servlet：Servlet用于处理请求和响应，是Web应用程序中与客户端直接交互的组件。
2.Filter：Filter用于在请求到达Servlet之前或者响应返回给客户端之前截获请求或者响应，并对其进行处理，比如修改请求或者响应、校验请求参数等。
3.Listener：Listener用于监听Web应用程序中的事件，比如ServletContext的创建、Session的创建销毁等，可以在事件发生时执行相应的逻辑操作。

13.结合项目再讲了讲业务难点，GC优化等相关东西

三、数字马力后端校招一面

1.操作系统:操作系统是一个什么样子的角色，操作系统有哪些分类

操作系统是负责管理和协调计算机硬件和软件资源的软件。它控制着计算机的运行，并为用户和应用程序提供服务。
操作系统可以分为以下几类：
1.批处理操作系统：能够一次处理大量的作业，并在计算机空闲时运行。
2.交互式操作系统：能够在计算机和用户之间提供实时的交互，支持多用户同时使用。
3.分时操作系统：能够将计算机资源划分为若干任务，让多个用户通过终端共享计算机资源。
4.实时操作系统：能够在一定时间限制内快速响应并处理外部事件，适用于需要高可靠性和实时处理的场景。
5.网络操作系统：能够支持计算机网络中的多个计算机之间的通信和数据共享。

2.计算机网络五层是什么，应用层有什么作用，应用层有哪些协议具体做什么，分层的意义是什么。

计算机网络五层分别是物理层、数据链路层、网络层、传输层和应用层。
应用层负责为用户提供各种网络应用服务，如电子邮件、文件传输、远程登录等。
应用层协议有很多，如HTTP协议用于Web访问，FTP协议用于文件传输，SMTP协议用于邮件传输等。
分层的意义在于方便网络协议的设计、实现和维护，同时也方便不同厂商的互通性和网络性能优化。

3.Java相关的:java的特性，了解jvm吗，了解gc吗，持续gc会导致什么。

Java的特性包括跨平台性、面向对象、自动内存管理以及强类型。JVM（Java虚拟机）是Java程序的运行环境。它可以在不同的操作系统和硬件平台上运行，实现了Java程序的跨平台性。GC（垃圾回收）是JVM提供的自动内存管理机制，它会自动检测和回收不再使用的对象，并释放内存空间。如果持续进行GC，会导致较低的性能和延迟，影响应用程序的运行效率。

4.你了解Redis里面的数据类型吗，zet的特点是什么，你觉得可以应用在你项目的哪里

Redis里面的数据类型有字符串（string）、散列（hash）、列表（list）、集合（set）和有序集合（sorted set）等。其中，字符串是最基本的数据类型，其他几种类型都是在字符串的基础上进行扩展和优化的。
ZSET（有序集合）的特点是：在集合的基础上增加了一个分数（score）字段，可以对集合中的元素进行排序，并且可以根据分数区间（区间查询）、元素值获取排名等操作，非常适合需要对数据进行排序，或者需要根据得分进行筛选的场景。

5.详细说说你在这个项目里面遇到的问题，怎么解决的。

四、 亚信安全Java开发工程师

1.hashmap和hashtable的区别

hashmap是一种数据结构，它使用哈希函数来存储键/值对，而hashtable则是hashmap的同步实现。hashmap允许空键和空值，而hashtable不允许。hashmap支持一个键多值，而hashtable不支持。hashmap是非线程安全的，而hashtable是线程安全的。

2.Spring的事务机制吗

Spring的事务机制是基于AOP的，通过注入代理对象来实现事务管理。Spring事务管理的核心是事务拦截器(TransactionInterceptor)，它负责在方法调用之前开启事务，在方法调用之后提交或回滚事务。Spring支持声明式事务和编程式事务两种方式，其中声明式事务是通过事务注解或XML配置来实现，而编程式事务是通过编写代码手动控制事务的开启、提交或回滚。

3.秒杀系统怎么设计

秒杀系统的设计应该考虑到多种因素，包括技术层面的实现、业务流程的优化、用户体验的改善等。在技术层面，可以考虑使用高性能的服务器来提升处理请求的速度，增加服务器容量来提高系统的承载量，使用缓存机制来提高数据访问的性能，并使用限流技术来控制系统的访问，以及使用队列机制来控制系统的负载等等。在业务流程方面，可以考虑简化秒杀流程，减少用户操作步骤，确保系统的稳定性和可用性，并且确保秒杀系统能够根据实际情况动态调整系统参数，以满足不同业务需求。

五、Java-2022暑期实习到2023春招部分面经

字节-商业化（已offer）

一面（40分钟）

1.讲讲你的即时通讯项目 发布订阅模式怎么实现的？ redis也有topic吗？ 那redis的topic底层原理怎么实现的？

即时通讯项目中的发布订阅模式，一般可以使用消息队列的方式实现。比如使用Redis中的Pub/Sub机制实现发布订阅功能。Redis是支持Pub/Sub机制，通过订阅某一个频道（Channel）可以接收该频道中的所有消息（Message）。
与此类似的，Redis中也有Topic的概念。Topic其实就是一组channel的集合，通过订阅某一个Topic，可以同时接收该Topic下所有channel的消息。
至于Redis的Pub/Sub底层原理，其实就是基于Redis的内部消息队列实现的。当一个客户端向Redis发送订阅命令时，Redis会将该客户端加入到指定频道的订阅列表中，并在内部开辟一个数据结构来维护该频道中所有订阅者的信息。当发布者向该频道发布消息时，Redis会将消息依次发送到每一个该频道下的订阅者。在这个过程中，Redis会为每一个客户端维护一个队列，当订阅者接收到消息后会将消息存放在自己的队列中，由订阅者自己主动去读取队列中的消息。
总之，发布订阅模式在即时通讯项目中是非常常见的一种通信模式，而Redis中的Pub/Sub机制则是非常实用的一种实现方式。

2.RPC项目呢，说一说 RPC也实现了ACK？

RPC（Remote Procedure Call）实现ACK的理解是，当客户端调用服务端提供的远程过程时，如果请求成功执行，则服务端会返回一个响应（Response）消息，通知客户端该请求已被处理完成。为了保证消息传输的可靠性，RPC协议还会引入ACK（Acknowledgement）机制，即在客户端接收到服务端的响应消息后，需要向服务端发送一个确认消息（ACK），告知服务端该响应消息已经被成功接收。这样可以避免消息在传输过程中丢失或者出现其他异常情况导致的消息丢失或者重复执行的问题。

3.TCP连接过程？ HTTP连接过程？说说WebSocket？

TCP连接过程：
TCP连接是一个三步握手的过程，分为如下步骤：
1.客户端发送 SYN 段给服务器，表示请求建立连接；
2.服务器端收到请求后，返回一个 SYN+ACK 段给客户端，表示同意建立连接；
3.客户端再发送一个 ACK 段给服务器，表示确认连接已经建立。
HTTP连接过程：
HTTP连接是在TCP连接的基础上建立的，在TCP连接建立之后，HTTP连接分为以下几个步骤：
1.客户端向服务器发送一个请求报文；
2.服务器接收到请求报文后，会向客户端发送一个响应报文；
3.客户端接收响应报文后，会关闭TCP连接。
WebSocket连接过程：
WebSocket连接是基于HTTP协议的，在建立连接时需要先建立一个HTTP连接，然后进行如下步骤：
1.客户端向服务器发送一个HTTP请求，请求使用WebSocket协议；
2.服务器接收到请求后，返回一个类似HTTP的101 Switching Protocols的响应，表示已经切换到WebSocket协议；
3.连接建立后，客户端和服务器可以进行双向通信。

4.HTTPS连接过程？CA证书怎样判断合法性？

HTTPS连接是一种通过使用SSL或TLS协议加密HTTP流量的网络协议，使通信过程更加安全可靠。下面是HTTPS连接的过程：
1.客户端向服务器发送HTTPS请求。
2.服务器将自己的SSL证书（包含公钥）返回给客户端。
3.客户端使用浏览器内置的CA根证书或操作系统中预装的CA根证书验证服务器证书的有效性（包括证书是否已经撤销）。如果证书不被信任或已被撤销，则浏览器会弹出错误提示。
4.如果证书被验证通过，客户端随机生成一个对称密钥（即会话密钥），并使用服务器的公钥加密发送给服务器。
5.服务器使用私钥解密收到的会话密钥，并将其用于加密和解密后续的通信。
6.双方使用会话密钥加密和解密通信内容。
要验证CA证书的合法性，需要进行以下步骤：
1.验证证书是否由可信的权威CA机构签发，即是否由浏览器或操作系统内置的CA机构颁发。如果不是，则可能是伪造的证书，需要谨慎处理。
2.验证证书的有效性，即证书的使用期限是否过期，是否已被吊销等情况。可以通过Online Certificate Status Protocol (OCSP)等工具来查询证书吊销状态。
3.验证证书的主体是否与对应的服务器地址相匹配，避免被中间人攻击。可以检查证书中的主体名称和通用名称是否与要访问的服务器地址相同。
例如CA机构根据服务器传过来的信息按照加密算法生成一个hash值并用私钥加密，嵌入数字证书中传给服务端；客户端校验时按照同样的加密算法生成hash，再用浏览器或操作系统内置的公钥解密证书，取出里面的hash，比较两个hash是否相等

5.数组、链表、栈、队列的区别，使用场景

数组（Array）是一组元素按顺序排列，每个元素可以通过下标来访问，它的大小在创建时就固定了。而链表（Linked List）由一个节点和指向下一个节点的指针组成，可以动态地增删改查节点。相比之下，数组的访问速度比较快，但是增删操作比较麻烦，而链表则相反，增删操作速度比较快，但是访问速度较慢。
栈（Stack）和队列（Queue）都是一种特殊的线性数据结构。栈是一种后入先出（LIFO）的结构，只能在栈顶进行插入和删除操作。而队列是一种先进先出（FIFO）的结构，只能在队尾插入元素，在队首删除元素。栈通常用于实现“后退”功能或括号匹配等场景，队列通常用于实现“先进先出”或“等待队列”等场景。
总的来说，选择哪种数据结构要根据具体的场景和需求。例如，需要频繁进行元素的访问操作，则可以优先使用数组；需要支持频繁的增删操作，则可以考虑使用链表；如果需要先处理最新的数据，则可以使用栈；需要处理多个任务或事件的队列，则可以使用队列。

6.ArrayList扩容过程 线程安全的ArrayList怎么办

ArrayList扩容过程的基本实现是：首先判断当前数组的容量是否已经满足要求，如果已满，则按照一定的策略进行扩容，通常将原有容量增加一半，并且创建一个新的数组，将原有数组中的元素复制到新的数组中。在这个过程中，如果存在多个线程同时对ArrayList进行操作，可能会出现竞争条件，导致数组的扩容操作出现问题。为了解决这个问题，可以采用两种方法：一种是使用Collections.synchronizedList(List list)进行包装，即将ArrayList包装成线程安全的List对象；另一种是使用CopyOnWriteArrayList，这种数据结构在并发性能上比较优异，但是相应的内存消耗也较大。

7.HashMap实现原理 ，concurrentHashMap实现原理

HashMap是一个基于哈希表实现的数据结构，它可以在O(1)的时间复杂度内完成插入、查找和删除操作。其实现原理是将每一个键值对映射到哈希表中，然后通过哈希函数计算键对应的桶索引，再在桶中进行链式查找或红黑树查找，找到对应的值。
而ConcurrentHashMap则是HashMap的线程安全版本。它在实现上使用了分段锁机制，将整个哈希表分成多个小的Segment（段），每个Segment都是一个独立的哈希表，每个线程对于不同的Segment都可以进行并发的访问操作，从而提高了并发性能。同时，在进行扩容或者删除操作时，也只需要锁住一部分Segment，而不是整个哈希表，减小了锁的粒度，提高了并发度

8.算法题：一道是实现加减乘除带括号的计算器，申请换了另一道题：leetcode 2035：将数组分成两个数组并最小化数组和的差

二面（一小时20分钟）

9.讲讲即时通讯项目 这种即时通讯的项目有啥注意的地方

在即时通讯的项目中，有以下几个需要注意的地方：
1.实时性：即时通讯的最大特点就是实时性，因此需要考虑系统架构、网络状况等因素来保证消息的实时性。
2.安全性：即时通讯的内容通常是私密的，因此需要采取一系列措施来确保消息的安全性，如加密传输、身份验证等。
3.用户体验：即时通讯是为了方便人们之间的沟通，因此在设计时需要考虑用户体验，如界面设计、消息推送等。
4.历史消息存储：通常需要存储聊天记录以便用户查看，需要考虑存储方式、数据安全等方面。
5.多平台支持：即时通讯一般需要支持多个平台，如移动端、PC端等，需要考虑统一的协议、数据格式等。

10.发布、订阅模式怎么实现的 为什么用redis不用其他

发布订阅模式通常用于解耦系统中的不同组件或模块，实现异步消息传递和事件驱动编程。Redis已经内置了发布/订阅功能，可以轻松实现简单的消息队列和事件处理。
Redis主要有以下优点，让其成为发布订阅模式的首选：
1.高性能：Redis是一个基于内存的键值存储数据库，可以快速存取数据，支持高并发的消息订阅和发布。
2.支持多种数据类型：Redis支持多种数据结构，如字符串、哈希表、列表、集合等，可方便地存储和处理丰富的数据信息。
3.可靠性高：Redis提供了持久化存储功能，可以将数据持久保存到硬盘，即使服务器宕机也能恢复数据。
4.简单易用：Redis操作简单，易于维护和扩展，同时提供了多种语言的客户端库。
因此，Redis作为一个内存型数据库，提供了高性能、多数据类型、可靠性高、简单易用等优点，成为了发布订阅模式的首选之一。

11.消息丢了或者乱序怎么办

这是一些可以解决消息丢失或乱序的方法：
1.确认ACK（确认消息收到）
在发送消息后，接收方应该通过发送一个ACK消息来确认已经收到了消息。这可以防止消息丢失。
2.序列号
序列号是一个唯一的数字，可以分配给每个消息。这可以确保消息按照正确的顺序到达目的地，即使它们并不是按照发送的顺序到达。
3.本地整流
本地重传会将丢失的消息重新发送。这可以确保消息不会丢失。本地整流可以在发送方和接收方之间使用。

12.谈一下Netty? Netty的Reactor模型和零拷贝机制 ?普通的IO过程是怎样的 ?Netty在应用层上实现了零拷贝，具体怎么实现的?

Netty是一个基于NIO的客户端/服务器框架，它提供了高度可扩展性和可靠性的网络编程能力。Netty的Reactor模型是指其事件驱动的异步IO模型，通过注册和监听事件的方式来处理客户端请求。Reactor模型中，所有的IO处理都运行在一个或多个线程池里，通过事件驱动的方式来异步处理IO操作。
零拷贝是指在数据传输的过程中，避免不必要的数据复制和移动，减少数据在内存中的拷贝次数，提高数据传输的效率。在Netty中，零拷贝机制是通过利用JDK提供的Direct Buffer，将数据从Socket通道读入到Direct Buffer中，再通过内存地址直接将数据传输到目标内存区域，从而避免了数据在内存中的复制和移动。
普通的IO过程是指，在读取或写入数据时，数据会被先读取到内核缓冲区，再被复制拷贝到用户缓冲区，最后再通过系统调用返回给应用程序。这种方式会产生大量的拷贝和数据移动，导致效率低下。而Netty利用了JDK提供的NIO API，使用了零拷贝技术，直接将数据从Socket通道读取到Direct Buffer中，再直接将数据传输到目标内存区域，从而避免了数据在内存中的复制和移动，提高了数据传输的效率。

13.Java里的IO以及操作系统里的select、poll、epoll是什么？怎么用？

Java中的IO是指输入/输出操作，可以用于读写文件、网络交互等。Java提供了多个IO库，例如InputStream/OutputStream、Reader/Writer等，可以根据不同的需求选择不同的IO库进行操作。
在操作系统中，select、poll、epoll都是用于处理I/O事件的机制。它们可以让程序通过一种非阻塞的方式来同时处理多个I/O请求。其中，select和poll在处理大量连接时效率较低，而epoll则可以避免该问题。
使用这些机制，可以通过将文件描述符添加到一个事件集合中，然后等待事件的发生。例如，在Java中，可以使用Selector类实现select/poll/epoll机制。

14.讲讲RPC

RPC（Remote Procedure Call）是一种远程调用协议，允许一个程序在网络中的另一个节点上执行一个子程序或函数，并将结果传递给主调用程序。RPC是一种客户端-服务器模型，通过网络协议进行通信。 客户端发起请求，服务器执行请求并返回结果。在实现RPC时，需要定义客户端和服务器之间通信所使用的协议以及数据格式。RPC被广泛应用于分布式系统和云计算领域中。

15.TCP三次握手四次挥手

TCP是一种传输层协议，用于在网络中可靠地传输数据。在TCP连接的建立和关闭过程中，使用了三次握手和四次挥手。
三次握手是指客户端向服务器发送一个SYN(同步)包，服务器接收到后回复一个SYN+ACK(同步和确认)包，表示服务器已经准备好建立连接，然后客户端再回复一个ACK(确认)包，表示客户端也准备好了。这三个步骤完成后，TCP连接就建立起来了。
四次挥手是指当客户端要关闭连接时，发送一个FIN(结束)包给服务器，表示客户端已经不需要这个连接了。服务器接收到后回复一个ACK包，表示服务器知道客户端要关闭连接了。随后，服务器发送一个FIN包，表示服务器也不需要这个连接了。最后，客户端回复一个ACK包，表示客户端知道服务器已经关闭了连接。
这样，TCP连接的建立和关闭就完成了。

16.TCP拥塞控制算法

TCP拥塞控制算法是一种网络拥塞控制机制，通过监测和调整发送数据的速率和窗口大小，以避免网络拥塞和拥堵。常见的TCP拥塞控制算法包括慢启动、拥塞避免和快重传等。这些算法的基本原理是当网络拥塞时，减少数据的传输速率和窗口大小，以避免数据包丢失和网络拥塞的进一步加剧。

17.死锁是什么，怎样解决？ 银行家算法？事务回滚的实现？ 死锁产生的四个必要条件 ？

死锁是指两个或多个进程（线程）互相等待对方所持有的资源，导致进程无法继续执行的一种状态。为了解决死锁问题，可以采用以下几种方式:
1.预防死锁: 通过破坏死锁的必要条件来预防死锁的发生，如破坏互斥条件、破坏请求和保持条件、破坏不剥夺条件等。
2.避免死锁: 在系统运行时避免死锁的发生，避免死锁的主要方法是安全序列算法。其中，银行家算法就是一种经典的避免死锁的算法。
3.检测死锁: 通过死锁检测算法，及时发现死锁的发生，并进行处理。
4.解除死锁: 通过资源剥夺和回滚等手段，使得死锁的进程发生回滚或终止，从而解除死锁。
银行家算法是操作系统中用来避免死锁问题的经典算法，通过对系统资源的分配和释放来预防死锁的发生。事务回滚的实现可以通过在事务执行过程中对操作进行记录，一旦发生错误或异常，可以将事务恢复到之前的状态。死锁的四个必要条件包括：互斥条件、请求和保持条件、不剥夺条件和环路等待条件。当这四个条件同时满足时，就会发生死锁。

18.数据库事务并发怎样解决幻读？

幻读指的是当一个事务在读取一个范围内的数据时，另一个事务在该范围内插入了新的数据，导致第一个事务再次读取时发现有新的行，产生了“幻觉”，因此称之为“幻读”。
解决幻读的一种方式是使用锁定机制，即在读取操作时，对范围内的数据进行锁定，防止其他事务进行插入操作。但是锁定机制会降低并发性能，因此一般只在必要时使用。
另一种方式是使用MVCC（多版本并发控制）机制，即在每个数据行上维护多个版本，并为每个事务提供一个特定版本的数据行。当事务读取数据行时，它会使用该事务的启动时间戳来获取该版本的数据行。这种方式可以在不阻塞其他事务的情况下解决幻读问题。

19.事务隔离级别

事务隔离级别是指在一个事务中的数据操作如何与其他事务相互影响的程度。SQL标准定义了四个隔离级别：读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）和串行化（Serializable）。隔离级别越高，可防止脏读、不可重复读和幻读等并发问题的能力越强，但可能会牺牲并发性。

20.事务四大特性ACID 分别怎么实现的

ACID是指原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）这四个特性。它们是确保事务在数据库中正确执行的重要特性。
原子性指事务是一个原子操作，要么全部完成，要么全部失败回滚，不会只完成部分操作。实现原子性的方式是通过在事务进行中的每个步骤都创建一个能够撤销所有操作的回滚记录。
一致性指在任何时间点，事务开始时和结束时，数据库都必须处于一致的状态。实现一致性的方式是通过设置约束和触发器来保证在任何时刻都不会违反数据的完整性。
隔离性指多个事务并发执行时，每个事务都应该能够独立地执行，不应该有任何相互干扰。实现隔离性的方式是通过增加锁机制以及在需要的时候使用事务隔离级别。
持久性指一旦事务提交，它的结果应该能够被持久保存在数据库中，不会丢失。实现持久性的方式是通过在每个事务提交时将其写入到日志文件中，保证即使系统崩溃也能够恢复到最近的事务提交状态

21.写过SQL优化吧，来看一道题 里面有个关键字没看见过

22.数据结构学过吧？说说循环队列 直接来写吧 手写循环队列

23…好，再来下一道，给定一个数组和一个数n，求出这个数组里的数字组成的小于n的最大数（数字可重复使用） 开始只能想到枚举，但根本不可能让写枚举，面试官给了点提示最后写了个大概，有点小bug 面试官说大问题没有，没问题。（md，两次字节面试都遇到生僻hard或者原创hard…）

三面（1个小时）

24.聊聊你的即时通讯项目

25.假设让你来设计一个校园即时通讯应用，IM服务器集群哈，你们学校假设现在有两万人，应该怎么设计，考虑哪些问题 高并发数据库压力过大、负载均衡 怎么解决？具体怎样实现？

对于校园即时通讯应用，应该首先考虑的是高并发访问和数据存储方面的问题。
为了应对高并发访问，可以使用分布式架构。可以采用微服务架构设计，将IM应用分成多个独立的服务，然后通过负载均衡器（如Nginx等）将请求分发到不同的服务器上，从而实现负载均衡。此外，可以使用消息队列（如Kafka、RabbitMQ等）实现异步处理请求，减轻服务器压力。
在数据存储方面，可以使用分布式数据库系统（如MySQL集群、NoSQL数据库等）来支持庞大的用户量和消息量。同时，还应该考虑数据的备份和恢复，以确保系统的可靠性和高可用性。
在实现方面，开发团队应该充分考虑系统的可拓展性和可维护性。为此，可以采用开源的IM框架（如OpenFire、Prosody、Ejabberd等）作为基础架构，并根据需求进行定制开发。
总之，设计校园即时通讯应用需要考虑诸多问题，包括高并发、数据库压力、负载均衡、可扩展性和可维护性等。通过使用分布式架构、分布式数据库系统、消息队列等技术手段，可以提高系统的可靠性和稳定性，确保IM应用在大规模使用时的正常运行。

26.假设现在我们有两台机器A和B在互相发消息，中间连接的是不同的IM服务器，这个消息收发过程是怎样的

在这种情况下，机器A首先将消息发送到它所连接的IM服务器上。IM服务器会将这个消息转发到第二个IM服务器，由第二个IM服务器将消息转发到机器B上。机器B接收到消息后，会先将消息存放在它所连接的IM服务器的缓存中，等待机器A发送的确认消息。一旦机器A发送确认消息，IM服务器会将确认消息转发回机器B，表示机器A已经成功接收到了这个消息。这个过程在两台机器之间持续进行，直到消息传递完成。整个过程需要考虑到网络延迟、消息丢失等各种情况，因此IM服务器在传递消息时需要进行一些额外的控制和处理，以保证消息的正确传递。

27.来看微信案例，我们PC微信端登录时会生成一个二维码要求手机端扫描，手机端扫描完毕后PC端才可以登录成功，请你描述这个过程发生了什么并详细阐述每个过程需要携带哪些信息

当我们在PC端登录微信时，服务器会生成一个二维码并返回给PC端。这个二维码包含了一个唯一的标识码，用于表示这个登录请求的身份。同时，服务器还记录了这个标识码对应的验证状态。PC端需要将这个二维码显示在屏幕上等待手机端扫描。
当手机端扫描二维码后，会将这个标识码通过手机端的微信APP发送回服务器进行验证。服务器会记录下这个标识码和验证状态，然后手机端需要将用户账号和密码信息通过微信APP发送给服务器进行登录认证。
如果账号和密码信息验证通过，服务器会将登录认证的令牌返回给手机端，并将该令牌与标识码关联起来。手机端需要将登录认证令牌发送回PC端，让PC端完成登录。PC端将令牌发送给服务端进行验证，如果验证通过，PC端就可以成功登录微信平台。
总的来说，该过程涉及到了二维码的生成和传输、用户账号密码的验证和认证、登录令牌的颁发和传输等多个环节，需要在这些环节中携带相关的信息，如标识码、账号密码和认证令牌等。

28.你这个项目实现过群聊消息功能吗 哪些点需要注意

29.写道题：最大连续子数组（2） 返回所有最大子数组

30.场景设计题：一个停车场，4*50 大小，汽车只能按行放置：小汽车占一个车位，收费10元，中汽车占两个车位，收费25元，大汽车占三个车位，收费50元。设计方案求最大利润？

滴滴-城运（三面挂）

一面（50分钟）

1.实习项目介绍 你负责什么 技术选型为什么是ClickHouse，对比过其他吗 新技术了解多少？

2.30天内数据做增量更新，怎么做的？

对于数据的增量更新，一般可以通过以下几个步骤来实现：
1.确定增量数据范围：根据最近一次更新的时间戳或者某个特定字段，筛选出需要增量更新的数据范围。
2.执行增量查询：使用数据库或者搜索引擎等工具，查询出需要增量更新的数据。
3.转换增量数据格式：将增量数据的格式与现有数据的格式统一，以便后续的处理。
4.合并增量数据：将增量数据与现有数据集成到一起，可以使用数据库的插入、更新、删除等操作，也可以使用脚本或者程序实现。
举个例子，比如我们有一个电商网站，需要每天更新商品价格信息。我们可以按照以下方式进行增量更新：
1.确定增量数据范围：通过记录最后一次更新的时间戳，筛选出从上次更新到当前时间需要更新的产品数据。
2.执行增量查询：使用数据库查询语句，查询出需要增量更新的产品信息。
3.转换增量数据格式：将查询结果转换为固定格式，例如JSON格式。
4.合并增量数据：使用数据库的插入、更新、删除操作，将增量数据与现有数据集成到一起，更新产品价格信息。
在实际应用中，可以根据数据类型、数据量、更新频率等情况，采用不同的增量更新方案，以提高数据更新效率和准确性。

3.标签问题，注意什么？

对于标签问题，我们需要注意实体识别和分类。实体识别是指识别出文本中提到的具体事物，如人名、地名、组织机构名等；分类则是将文本归入某种类别，如情感分类、主题分类等。正确的标签对于进行文本分析和数据挖掘非常重要，因此需要仔细进行处理。

4.ClickHouse为什么快？如何用clickhouse做增删改操作？ClickHouse的弊端是什么？

ClickHouse之所以快，是因为它采用的是列式存储和压缩算法，能够节省磁盘空间和提高查询性能。而且，ClickHouse还采用了分布式架构和多线程处理，使得它能够轻松地处理大规模数据。
在ClickHouse中进行增删改操作，需要使用INSERT、UPDATE和ALTER命令。具体的操作方式，可以参考ClickHouse的官方文档。
不过，需要指出的是，ClickHouse的弊端是不支持事务和复杂的JOIN操作，也不支持像MySQL那样的主从同步复制功能。所以，需要根据具体的业务场景来选择适合的数据库系统。

5.其他想展示的项目亮点 即时通讯及时性、可靠性、未读数冗余设计

6.TCP三次握手、四次挥手、可靠传输原理 和UDP区别，UDP好处，适用场景

TCP三次握手是指在TCP协议中建立连接时，客户端发送SYN请求给服务器端，服务器端回复SYN+ACK确认信号给客户端，最后客户端再回复ACK确认信号给服务器端，完成连接建立。四次挥手是指在TCP连接关闭时，客户端发送FIN请求给服务器端，服务器端回复ACK确认信号给客户端，服务器端再发送FIN请求给客户端，客户端回复ACK确认信号给服务器端，最后连接关闭。
可靠传输原理是指在数据传输时，对数据进行多次确认，保证数据能够正确到达目标地址。TCP协议具有可靠传输原理，而UDP协议没有。
UDP协议与TCP协议相比，优点是传输速度快、传输延迟低、传输的数据量较小。它适用于一些实时要求较高、容忍数据丢失的场景，例如实时游戏、音视频传输等。
适用场景：
UDP适用于需要实时性较高，对数据传输成功率要求较低的场景，例如网络游戏中的实时动作、多媒体信息传输、DNS域名解析等。而TCP适用于需要保证数据传输准确性和成功率的场景，例如网页传输、文件上传等。

7.Redis的数据类型挑一个说说，底层结构

Redis中常见的数据类型包括：String、Hash、List、Set、Sorted set。
以String为例来说说底层结构。在Redis中，String类型的值被存储在RedisObject中，这个对象中有一个指向String类型的指针，指向存储在Redis数据库中的；此外还有一个指向StringFlags结构的指针。RedisFlags结构是一个4字节长的结构，它指定了字符串对象与其他类型对象的类型编码。
String类型底层是基于字节数组实现的，其中字符串的长度被保存在变量len中，而字符串的实际数值则被存储在char数组buf中。因此，我们可以快速地访问String类型数据的内容并进行操作。

8.Java NIO、BIO、操作系统IO

Java NIO（New Input/Output）是Java中的一种基于缓冲区、非阻塞、事件驱动的IO方式。BIO（Blocking I/O）是同步阻塞型的IO方式，它的特点是在IO执行的过程中，阻塞当前线程，无法响应其他操作。操作系统IO是指操作系统提供的原生IO接口，它与具体的编程语言和框架无关，可以通过系统调用来实现。

9.手写HashMap，实现put、set、size方法。

HashMap是Java中用来存储键值对的一种数据结构，实现put方法时需要使用哈希算法来确定键值的位置，set方法用于更新已有的键值对，size方法用于返回HashMap中键值对的数量。

二面（35分钟）

10.实习项目…

11.列式数据库一定比行式数据库快？为什么

不是一定的。在特定的情况下，列式数据库可能会比行式数据库更快，但在另一些情况下，行式数据库会更快。
列式数据库在操作列数据时非常高效，因为数据存储在连续的块中，这使得查询特定列的数据变得更加快速。另一方面，行式数据库在操作行数据时非常高效，因为它们检索记录必须用到多个不同的列。
因此，选择何种类型的数据库取决于你的具体需求和查询模式。如果查询需要访问且操作的列很少，那么列式数据库会更快。如果查询需要访问多个列和记录，那么行式数据库将更加适合。

12.在字节学到了什么 工作中遇到了问题怎么解决 看哪些书 你认为自己性格是怎样的 对技术的认识，未来的职业规划…

三面（35分钟）

13.实习项目介绍

14.关注哪些技术网站 有了解新技术不

15.JVM垃圾回收

JVM垃圾回收算法主要有标记-清除、复制、标记-整理和分代四种。其中标记-清除算法会产生内存碎片，复制算法适用于存活对象较少的场景，标记-整理算法整理后的内存布局比较紧凑，分代算法则是将堆空间分为新生代和老年代，采用不同的回收算法适应不同的对象存活特点。

16.看你自己写过线程池，聊聊线程池 注意什么，线程池存在的一个问题，一个线程想使用上一个线程的上下文解决方案？

在多线程编程中，可以使用一些同步机制，比如锁、信号量等来实现线程之间的数据传递和共享。如果是在函数调用中，可以使用参数或者全局变量等方式来传递数据。如果您可以提供更具体的情境，我可以给您提供更精确的答案。

17.JDK8新特性

一些JDK8的新特性包括Lambda表达式、函数接口、Stream API、默认方法、日期时间API等。

18.RPC项目里消息总线替代Zookeeper集群的解决方案怎么做？

关于RPC项目里消息总线替代Zookeeper集群的解决方案，一种可行的做法是使用基于HTTP的消息队列（如RabbitMQ或Kafka），将消息传递给服务之间进行通信。采用这种方法可以避免Zookeeper的单点故障问题，也能够通过消息队列实现服务的扩展性和负载均衡。当然，具体实现还需要结合系统的实际情况来进行选择和调整。

19.即时通讯用的什么传输协议 序列化协议

美团-到店（HR面挂）

一面（12.27 一小时）

1.Java并发ReetrantLock锁底层实现，CAS、AQS Java内存模型，原子性怎么保证，可见性怎么保证，底层原理 Java线程池实现原理 拒绝策略有哪些 volatile关键字

Java中的ReentrantLock是一种可重入的互斥锁，它的底层实现依赖于CAS（Compare and Swap，比较并交换）算法和AQS（AbstractQueuedSynchronizer，抽象队列同步器）框架。CAS算法是一种无锁算法，在Java中通过sun.misc.Unsafe类来实现。它利用CPU底层的原子指令完成对内存中的数据进行原子性操作，保证了数据的一致性。而AQS框架则是一种实现锁、信号量等同步操作的基础框架，主要通过 FIFO 队列实现等待机制，同时提供了公平锁和非公平锁两种实现方式。
Java内存模型是一种抽象的概念，它定义了各种线程在何时、何地和如何访问共享内存。Java内存模型通过保证原子性、可见性和有序性来保证线程之间的并发执行正确性。其中原子性是指操作的不可分割性，比如对于32位的数据，它们必须被一次性地读取或写入，不能被分解成两个16位的操作。可见性是指对于共享变量的修改对于其他线程来说是可见的，主要通过volatile关键字和synchronized关键字来保证。有序性是指执行顺序必须满足一定规则，比如一个事件在发生前必须先发生另一个事件。
Java线程池是一种可以提高程序性能的技术，在Java中通过ThreadPoolExecutor类来实现。它主要包括核心线程池、任务队列、最大线程池、线程工厂和拒绝策略等几个部分。其中核心线程池和最大线程池决定了线程池的线程数量，任务队列决定了线程池中的任务调度策略，线程工厂则决定了线程池中线程的创建方式，而拒绝策略则是当任务队列已经满了且线程池中的线程已被占用时，如何处理新的任务请求。

Java线程池的拒绝策略有以下四种：
1.AbortPolicy：直接抛出RejectedExecutionException异常，阻止系统正常运行。
2.CallerRunsPolicy：只要线程池还没有关闭，该策略直接在调用者线程中执行当前任务，即同步执行任务。
3.DiscardPolicy：直接丢弃当前任务，什么也不做。
4.DiscardOldestPolicy：丢弃最早进入队列的任务，然后尝试重新提交当前任务。
volatile关键字是一种Java线程间的同步机制，它保证一个变量在多个线程之间的可见性，也能保证一定程度的指令重排序。当一个变量被声明为volatile后，所有线程都能看到这个变量的最新值，而不管这个变量是否在本地CPU缓存中。

2.字节实习项目 你负责做了什么 怎么没留在字节

3.讲一讲你做的这个RPC框架，核心原理 具体每个部分怎么实现的 , zookeeper集群的强一致性优化，

RPC框架的核心原理是远程调用，其具体实现包括以下几个部分：
1.序列化/反序列化：将传输的数据转换成字节流或从字节流反序列化为对象，以便在网络上进行传输。
2.传输协议：定义了在通信过程中使用的网络协议，如TCP、UDP等。
3.网络传输：将序列化后的数据通过传输协议在网络上传输。
4.消息编解码：将网络传输的字节流解码为可调用的远程方法，以便在服务端执行。
5.路由和负载均衡：确定哪个远程服务实例应该处理请求，并在多个实例之间分配请求负载。
以上是RPC框架实现的核心部分，其不同的实现方式可以根据具体要求来选择不同的序列化方式、传输协议等

针对 ZooKeeper 集群的强一致性优化，可以从以下两个方面入手：
1.优化 ZooKeeper 的集群配置：通过增加 ZooKeeper 的网络带宽、提高 ZooKeeper 节点的 CPU 和内存等资源，优化 ZooKeeper 的集群配置，从而提高 ZooKeeper 集群的性能和稳定性。
2.优化 ZooKeeper 的应用程序：在应用程序中，可以使用 ZooKeeper 的 Watcher 机制实现数据变更的监听，并使用 ZooKeeper 的版本号机制实现数据的版本控制，从而保证数据的强一致性和可靠性。此外，可以将数据的写入操作和读取操作分别放在不同的 ZooKeeper 节点中实现，从而提高 ZooKeeper 集群的读写性能。

4.写道算法 中等题 对你肯定没问题吧查找算法有哪些 为啥这里可以用二分 那如果有序链表怎么实现二分查找的效果——可以考虑新开辟一个数组空间记录链表位置 限制空间呢？你听过跳表吗 知道，redis里就用到过 redis里哪里？跳表原理

携程-旅游（至今泡池子）

1.接口和抽象类区别

接口和抽象类都是面向对象编程中的重要概念。它们的最基本区别是，抽象类可以包含实现代码，而接口不能包含任何实现代码，只能包含方法签名。
抽象类是一种抽象的基类，不能实例化。它必须被子类继承，并且子类必须实现它的抽象方法。抽象类可以包含抽象方法、虚方法或实现代码。它通常用于一组相关的类共有的属性或方法的抽象化。
接口是一种类似于抽象类的抽象概念。它是一个纯粹的抽象定义，不能包含任何实现代码或实例字段，只能包含方法和属性声明。实现接口的类必须实现接口中所有的方法和属性，否则编译器会报错。
因此，接口主要用于实现多态性和接口隔离原则，而抽象类主要用于实现继承和封装。在实际开发中，应根据具体场景和需求选择使用抽象类还是接口。

2.Java反射是什么 实现原理

Java反射是指在运行时动态地获取类的信息以及对类成员(属性、方法、构造方法等)进行获取和调用操作的机制。实现原理是通过Java的类加载机制，将Java源代码编译为字节码文件，程序在运行时通过类加载器加载字节码文件并在内存中创建相应的类信息(例如：构造方法、属性、方法等)，通过这些类信息可以实现对类成员的调用和操作。反射是Java编程中非常重要的一种技术，常用于框架、插件、动态代理等开发场景中

3.集合接口有哪些 哪些是线程安全的 想要保证线程安全怎么办

Java中集合接口有List、Set、Map等，线程安全的集合有ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList等。为了保证线程安全，我们可以使用synchronized关键字加锁或者使用线程安全的集合类。同时，也可以使用并发工具类中的Lock接口或者ReadWriteLock接口实现线程安全。

4.HashMap原理 与ConcurrentHashMap原理分别是什么？

HashMap是一个基于哈希表实现的Map接口的数据结构。它使用哈希表来存储和访问键值对，哈希表中每个元素都是一个桶，里面存放着一个链表或红黑树，其中链表包含了哈希值相同的键值对，而红黑树则用于优化查找效率。当我们要插入或查找一个元素时，HashMap会先根据键的哈希值找到对应的桶，然后再遍历桶中的链表或红黑树，找到目标元素。
ConcurrentHashMap与HashMap类似，也是一个基于哈希表实现的Map接口的数据结构。不同之处在于它支持多线程并发操作。在ConcurrentHashMap中，哈希表被分为了多个分段（Segment），每个分段内部维护着一个与HashMap类似的数据结构，多个线程可以同时对不同分段进行访问。这就避免了多线程访问时的线程竞争问题，从而提高了并发性能。另外，在ConcurrentHashMap中，读操作不需要加锁，只有写操作需要加锁，因此在多线程读写混合的场景下，ConcurrentHashMap的性能更好。

5.垃圾收集算法

垃圾收集算法（Garbage Collection Algorithm）是一种自动内存管理机制，通过识别无用的内存对象并释放它们来提高内存使用效率。常见的垃圾收集算法有标记清除、引用计数、复制、标记整理等。每种算法都有其优缺点，需要根据具体情况来选择合适的算法。

6.进程和线程的区别

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

7.ReentrantLock锁实现原理，那CAS是啥

ReentrantLock是一种可重入的独占锁，基于AQS（AbstractQueuedSynchronizer）实现。它通过维护一个同步队列和一个状态变量，来控制共享资源的访问。线程获取锁会进行CAS操作，尝试将状态变量由0改为1，若成功则表示获取锁，若失败则将线程加入同步队列。释放锁时，则将状态变量由1改为0，并唤醒同步队列中的下一个线程。
CAS（Compare-And-Swap）是一种无锁算法，用于解决并发环境下的数据共享问题。它的原理是通过比较内存中某个位置的值和给定的旧值，若相等则更新该位置的值为新值。CAS操作需要硬件的原子性支持，常常被用来实现锁、计数器等并发控制机制。

8.创建线程的方法有哪些？ 核心参数有那些？ 创建线程的流程是什么？

在Java中，可以通过以下两种方式创建线程：
1.继承Thread类，并重写run()方法；
2.实现Runnable接口，并实现run()方法。
创建线程时，可以使用以下核心参数：
1.线程的名称；
2.线程是否为守护线程；
3.线程的优先级；
4.线程所属的线程组。
线程的创建流程如下：
1.创建线程类（继承Thread类或实现Runnable接口）；
2.重写run()方法，在其中定义线程执行的代码；
3.创建线程对象；
4.调用start()方法启动线程。
在线程启动后，线程会进入就绪状态，等待CPU调度。当线程得到CPU的调度后，会进入运行状态，执行run()方法中的代码。线程执行完成后，会进入死亡状态。

9.事务的四大特性ACID及底层实现是什么？

ACID是指原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability），是指数据库事务在进行处理时需要满足的四个特性。底层实现可以通过在数据库管理系统中使用日志文件来实现这些特性。日志文件记录了每次数据库的读写操作，以便在失败时进行恢复。通过在事务开始时创建一个日志记录，在事务结束时将日志记录存储到磁盘上，并且只有在这些记录都被写入到磁盘时才完成事务，以实现持久性。在同时进行多个事务时，为了避免数据不一致的问题，数据库管理系统需要实现隔离性，以确保每个事务都能够访问到最新的数据。为了实现原子性和一致性，可以使用锁定机制来控制对数据库的访问。

10.Mysql索引分类和结构是什么？Mysql索引为什么是B+树 ？哪些场景下需要建索引？索引失效的情况有哪些？

Mysql的索引分类有聚集索引和非聚集索引，结构有B树索引和哈希索引。Mysql索引采用B树结构的原因是因为B树可以以一定的时间复杂度快速搜索到目标节点，并且B树可以自平衡，适应插入和删除操作频繁的场景。需要建索引的场景包括频繁作为查询条件的列、连接条件的列、排序和分组的列等。索引失效的情况包括查询条件未使用索引、where子句使用了函数或表达式、索引列类型不匹配等

11.Redis数据类型

Redis数据类型包括字符串、哈希、列表、集合、有序集合和 HyperLogLog。其中，字符串是最基本的数据类型，其他数据类型都是在字符串的基础上来的。哈希类型是一个键值对的集合，列表类型是一个有序的字符串列表，集合类型是一个无序的字符串集合，有序集合可以给每个字符串赋予一个分数，而 HyperLogLog 用于处理基数（cardinality）估算问题。

12.如何保证数据库和缓存的一致性

采用以下几种方法来保证数据库和缓存的一致性：
1.固定优先使用数据库中的数据，然后再考虑缓存中的数据。
2.在更新数据库时，同时更新缓存中的数据。可以采用缓存穿透和缓存雪崩的策略，以避免对缓存造成过大的压力。
3.使用订阅/发布机制，当数据库发生变化时，通知缓存进行更新，以确保数据的一致性。
4.周期性地同步更新数据库和缓存中的数据，以防止数据出现大的偏差。

13.Spring你了解吗 说说Spring的Bean…

Spring中的Bean是一个由Spring IoC容器管理的对象。Spring IoC容器负责生命周期管理，即创建、初始化、配置和销毁这些Bean。
Bean的生命周期包括以下三个阶段：
1.实例化（Instantiation）：Spring容器使用Java的反射机制创建一个Bean实例；
2.初始化（Initialization）：调用Bean的初始化方法或者自定义的初始化方法；
3.销毁（Destruction）：当Bean不再需要时，Spring容器会回收Bean并调用Bean的销毁方法或自定义的销毁方法。
在Bean的生命周期中，Spring框架提供了以下5个接口来进行扩展:
1.BeanFactoryPostProcessor
2.BeanPostProcessor
3.InstantiationAwareBeanPostProcessor
4.DestructionAwareBeanPostProcessor
5.BeanPostProcessorRegistry
这些扩展接口可以帮助开发人员在Bean的生命周期中添加一些自定义逻辑。例如，可以使用BeanPostProcessor在Bean的初始化前后添加一些逻辑，使用DestructionAwareBeanPostProcessor在Bean销毁前后添加一些逻辑等。

14.Java中有哪些设计模式 ？ 工厂模式详细说下，起了什么用，怎么做

关于Java中的设计模式，常见的有以下几种：
1.工厂模式（Factory Pattern）
2.单例模式（Singleton Pattern）
3.观察者模式（Observer Pattern）
4.装饰者模式（Decorator Pattern）
5.策略模式（Strategy Pattern）
6.适配器模式（Adapter Pattern）
7.模板方法模式（Template Method Pattern）
8.委托模式（Delegate Pattern）
其中，工厂模式是一种常用的创建型模式，其主要用途是为了解除创建对象的类与使用对象的类之间的耦合关系，提高代码的封装性和可维护性。它通过定义一个工厂方法来创建产品，让子类来决定实例化哪个具体的类，实现了对实例化过程的控制。
工厂模式大致包含以下几个组成部分：
抽象工厂（Abstract Factory）：它是工厂方法模式的核心，用于定义创建对象的接口。
具体工厂（Concrete Factory）：实现抽象工厂接口，用于创建具体的产品对象。
抽象产品（Abstract Product）：定义了产品的接口。
具体产品（Concrete Product）：实现抽象产品接口，由具体工厂创建。

15.RPC原理？协议头如何设计？ 分布式场景下分布式ID如何生成？

RPC原理是通过网络来实现不同进程或服务之间的通信，使得它们能够像调用本地函数一样直接进行通信。其实现原理主要包括序列化、传输、反序列化等步骤。在序列化过程中，将需要传输的数据按照一定的协议格式编码成二进制数据；在传输过程中，则需要使用网络协议进行传输，如TCP、HTTP等；在反序列化过程中，则将接收到的二进制数据解码成需要的数据格式。
协议头的设计一般是按照一定的规范来进行设计的，如HTTP协议头中包括请求方法、请求URI、协议版本、请求头等；TCP协议头中则包括源端口、目的端口、序列号、确认号等等。协议头的设计需要考虑到通信所需的信息，以及协议的可靠性、安全性、扩展性等方面的要求。
在分布式场景下，分布式ID生成一般是通过分布式算法来实现的，如雪花算法、UUID算法等。雪花算法通过在ID生成器中设置机器ID、序列号等信息来产生唯一的ID；UUID算法则是通过基于时间戳、随机数等来生成唯一ID。分布式ID生成需要考虑到算法的唯一性、速度性能等方面的要求。

16.JDK代理与第三方代理的区别是什么，各有什么优缺点？

JDK代理和第三方代理的区别主要在于实现方式和使用场景。JDK代理是指直接使用Java内置的反射机制来进行代理，而第三方代理则是使用外部框架或类库来实现代理。
JDK代理的优点是不需要引入额外的依赖，使用方便，可以灵活控制代理的行为，比如修改参数、记录日志等。缺点是只能代理接口（或者实现了接口的类），不能代理普通的对象；并且生成的代理类不能重复利用，每次调用都需要重新生成。
而第三方代理的优点是可以代理任何对象，不受类型限制，并且可以代理类的具体方法。同时，第三方代理框架的功能更丰富，比如支持动态修改代理行为、切面编程等。缺点是需要引入额外的依赖，使用稍微复杂一些；同时，可能存在性能上的一些损失，比如动态生成字节码等。
选择哪种代理方式要根据具体的业务场景和需求进行评估，权衡各自的优缺点，并选择适合自己的方式。

17.Zookeeper集群和消息总线设计详细说

关于Zookeeper集群的设计，一般采用奇数个节点的方式搭建，例如3、5、7个节点等，其中一些节点会被选为leader节点来协调和管理整个集群的状态，而其他节点则作为follower节点来与leader节点进行信息同步和数据备份。
在Zookeeper集群中，节点间会保持心跳等机制保证节点的健康和可用性；同时，使用ZAB协议（Zookeeper Atomic Broadcast）实现leader节点的选举、事务处理等操作，并通过分布式锁Zookeeper实现分布式共享锁等功能。
而对于消息总线的设计，一般采用中心化的架构，如Apache Kafka，通过Kafka Broker来管理、存储和转发消息；同时，支持多个生产者和消费者，以及多个topic的实现。Kafka采用持久化的方式保存消息，确保消息不会因为服务宕机等异常情况丢失，而且支持多个副本的备份，提高数据可靠性；同时，支持流处理框架如Apache Flink等，实现实时计算等高级功能。

18.介绍即时通讯项目，如果改成分布式的，应该要注意哪些问题

美团-酒旅（二面结束两周挂）

美团一面（1小时15分钟）

1.点开一个微信小程序文章，这个过程后台发生了什么

2.HashMap实现原理什么?，详细描述一下put过程？线程安全的map实现有什么？ 为什么用红黑树不用AVL树？

HashMap是将存储的key-value映射到一个索引上，以实现快速查找和访问的数据结构。它使用一个数组来存储元素，通过hash算法计算key的哈希值，将其映射到数组的一个位置上。如果该位置上已有元素，那么就使用链表或红黑树来解决哈希冲突。
当执行put操作时，首先会根据key计算哈希值，并将其映射到数组的一个位置上。如果该位置上没有元素，那么就直接将该key-value作为一个新的元素添加进去。如果该位置上已有元素，则需要比较key是否相同。如果相同，则用新的value替换原来的value，如果不相同，则使用链表或红黑树解决冲突，将新的key-value插入到链表或红黑树中。如果链表的长度达到一定的阈值，就会将链表转换为红黑树来提高查找效率。
线程安全的map实现有ConcurrentHashMap。它使用分段锁来保证多线程并发操作的安全，并且只对同一段内的元素进行加锁，不会阻塞整个表的访问。
红黑树相对于AVL树的优势在于，对于更新操作（如插入、删除），红黑树需要的旋转操作更少，因此效率更高。而AVL树的优势在于查询时的效率更高，因为它保证左右子树的高度差不超过1，使得整个树更加平衡。但在实际应用中，由于大部分情况下更新操作和查询操作的比例是1:10或1:100，因此红黑树更适合作为一般的平衡树使用。

3.synchronized原理， volatile原理

Synchronized是Java中的一个关键字，用于实现对资源的同步访问。在Java中，每个对象都有一个锁，当某个线程需要访问对象的同步代码块时，它必须先获得该对象的锁。当该线程执行完同步代码块后，会自动释放该对象的锁。这样，其他线程才能获得该对象的锁，从而访问对象的同步代码块。当一个线程持有一个对象的锁时，其他线程不能获得该对象的锁，也不能访问该对象的同步代码块。而synchronized关键字就是用来实现这个机制的。
Volatile也是Java中的一个关键字，用于实现多线程之间的变量可见性和禁止指令重排。在Java中，当一个变量被定义为volatile时，它会被存储在主内存中，而不是线程的工作内存中。这意味着对该变量的读操作和写操作都是直接从主内存中进行的，而不是从线程的工作内存中进行的。同时，volatile变量的写操作会立即刷新到主内存中，而不是等到线程执行完毕才刷新。这样，就可以实现多线程之间的变量可见性和禁止指令重排。

4.线程池是什么？有那些核心参数？ 线程数目该怎样设置？ ThreadLocal是什么？

线程池是一种用来管理和重用线程的技术，它可以减少线程创建和销毁所造成的开销，提高线程的利用率和系统的并发性能。线程池的核心参数包括：核心线程数、最大线程数、线程存活时间、工作队列类型、工作队列容量等。
核心线程数是线程池保留的最小线程数目，即使线程处于空闲状态也不会被销毁，用于保证系统的稳定性和实时性。最大线程数是线程池允许的最大线程数目，当工作队列已满且线程数目小于最大线程数时，会新建线程并加入线程池中，以满足更高的并发性能。线程存活时间指的是线程在空闲状态下的最大存活时间，超过该时间即使空闲也会被销毁，用于动态调整线程池的规模。
线程数目应该根据系统的负载情况、处理能力和并发性能进行设置，一般来说，线程数目越多并不意味着并发性能越好，反而会浪费系统资源和导致竞争瓶颈。应该根据实际情况进行测试和调优，找到最优的线程数目。
ThreadLocal是一种线程本地变量技术，它可以让每个线程都拥有自己的局部变量，从而避免了线程之间的竞争和同步，提高了线程的执行效率和程序的可靠性。ThreadLocal中的变量只能被当前线程访问和修改，其他线程无法获取和修改它，因此可以充分利用线程的局部性和隔离性，减少了各个线程之间的干扰和错误。ThreadLocal可以被用于实现线程安全和上下文切换等功能。

5.用过哪些设计模式，具体举例

关于Java中的设计模式，常见的有以下几种：
1.工厂模式（Factory Pattern）
2.单例模式（Singleton Pattern）
3.观察者模式（Observer Pattern）
4.装饰者模式（Decorator Pattern）
5.策略模式（Strategy Pattern）
6.适配器模式（Adapter Pattern）
7.模板方法模式（Template Method Pattern）
8.委托模式（Delegate Pattern）
其中，工厂模式是一种常用的创建型模式，其主要用途是为了解除创建对象的类与使用对象的类之间的耦合关系，提高代码的封装性和可维护性。它通过定义一个工厂方法来创建产品，让子类来决定实例化哪个具体的类，实现了对实例化过程的控制。

6.Java内存区域是什么？ 垃圾收集算法有那些？ 方法区可能出现GC吗？ 如何决定哪些对象被GC？

Java内存区域包括堆、栈、方法区、程序计数器和本地方法栈。Java中常见的垃圾收集算法有标记清除、复制、标记整理和分代收集等。方法区可能会发生GC，比如在加载大量类的时候会占用很多方法区的空间，当方法区空间不足时会触发GC。决定哪些对象被GC通常由垃圾收集器自动处理，根据对象是否可达来判断是否需要回收。可达性分析算法是最常用的算法。

7.InnoDB索引结构是什么？为什么是B+树？ 事务四大特性是什么？

InnoDB索引结构是B+树。B+树在存储大量数据时能够保持较低的树的高度，使得查询数据时的I/O操作数量较少，在大数据量的情况下能够大幅提升查询性能。而B+树采用了叶子结点链表的形式，使得范围查询和排序等操作更为高效。
事务四大特性是：原子性、一致性、隔离性、持久性。原子性指事务在执行过程中不可分割，要么全部执行，要么全部回滚；一致性指事务执行前后数据库都必须处于一致性状态；隔离性指多个事务之间要互相隔离，互不影响，各自独立执行；持久性指一旦事务提交后，其结果就将被永久保存在系统中，即使出现系统崩溃也不会丢失。

8.InnoDB和MyISAM区别？数据库锁的实现原理？

InnoDB和MyISAM是MySQL数据库使用的两种存储引擎。它们之间的主要区别是在于数据存储方面的不同，例如事务处理、表锁机制等等。
InnoDB是一种支持事务处理的存储引擎，支持行锁定和外键约束等功能，可以保证数据的一致性和完整性。而MyISAM则是一种不支持事务处理的存储引擎，表级锁定，对并发的处理支持较差。
就数据库锁来说，MySQL使用的锁类型有两种，分别是行锁和表锁。行锁只锁定数据行，而表锁则锁定整个表。InnoDB使用行锁，可以在高并发的情况下保证不同线程对相同数据不会发生冲突。而MyISAM则是使用表锁，不能同时处理多个并发请求，导致性能较低

9.Redis是什么？ Redis怎么做分布式锁？

Redis是一种开源的、基于内存的高性能键值对存储系统，可以用来做缓存、消息队列和排行榜等应用。它支持多种数据结构，如字符串、哈希表、列表、集合和有序集合等。
如果要在Redis中实现分布式锁，可以用SET操作来创建一个带有过期时间的键，用来表示某个资源是否被锁定。多个客户端可以通过SETNX命令来竞争获取该锁，成功获取锁的客户端可以使用DEL命令来释放锁，或者利用Redis的过期时间机制来自动释放锁。同时，还可以加入一些附加的特性，如重入、可重试、公平锁等。

10.数据库和缓存一致性如何保证

数据库和缓存一致性有多种保证方式，其中比较常用的方式包括：
1.双写：每次数据更新操作同时向数据库和缓存写入数据，保证数据一致性。
2.延时双删：数据更新操作只向数据库写入数据，同时将缓存数据标记为已过期，缓存中的数据在下一次请求时被删除，下一次查询时从数据库中读取最新数据写入缓存。
3.更新缓存：每次数据更新时，通过消息队列将新数据更新到缓存中，保证缓存和数据库数据的一致性。
4.只写缓存：只向缓存中写入数据，在读取时如果发现缓存没有数据，则从数据库中读取，并将读取到的数据写入缓存。这种方式适用于数据频繁读取，但很少更新的场景。
以上是常见保证数据库和缓存一致性的方式，不同的应用场景可以根据需求选择不同的方式。

11.操作系统的IO模型，异步IO的理解，与信号驱动IO的区别

操作系统的IO模型包括阻塞IO、非阻塞IO、IO多路复用和异步IO。在阻塞IO模型下，当进程调用IO操作时，进程会一直阻塞等待IO操作完成。而在非阻塞IO模型下，进程会立即返回，无论IO操作是否完成。下一步，进程会进行轮询，检查IO操作是否完成。IO多路复用模型则是进程把多个IO操作注册到一个特殊的内核文件描述符上，当某个IO操作完成，进程从内核得到通知。异步IO模型与IO多路复用模型相似，不过是将通知采用回调函数的方式进行。
异步IO的理解是，当进程调用后台IO操作时，系统会立即返回给进程，同时进程会得到一个标记，标识该IO操作正在进行中。进程可以继续执行其他操作，当IO操作完成时，操作系统会通过回调等方式通知进程获得结果。异步IO与常规的阻塞IO和非阻塞IO相比，能够更充分地利用CPU和IO资源，提升性能。
信号驱动IO是一种在IO操作完成之后，由系统向进程发送信号的方式，让进程得知IO操作的完成。与阻塞IO和非阻塞IO不同的是，信号驱动IO不需要进程轮询IO事件。与IO多路复用和异步IO相比，信号驱动IO的实现较为繁琐。

12.linux 常用命令有那些？cat、awk表示什么？

常用的 Linux 命令有：cd、ls、pwd、mkdir、rm、cp、mv、gzip、tar、ssh、scp 等等。其中，cat 命令用于显示文件内容，awk 命令是一个用于处理文本数据的命令行工具，可以轻松过滤、格式化和重组文本数据。

13.介绍下Netty，它为什么快？Netty的零拷贝是什么？

Netty是一个高性能的异步事件驱动的网络应用程序框架。它采用了NIO技术，可以处理大量的并发连接，且具备异步IO性能的优点。Netty使用了对JDK原生API的封装和优化，使用EventLoop进行异步事件处理，可以提高网络IO的效率，避免了传统IO阻塞式的缺点。
Netty的零拷贝是指在进行网络传输的过程中，数据不需要被复制多次。比如，当从磁盘读取数据后，传统方式需要将数据复制到操作系统的缓存中，再将其复制到应用程序的内存空间中，最后再将其复制到网络套接字缓存中，而Netty则可以避免这些多余的复制，从而提高了性能。具体的实现方式包括：使用ByteBuf代替Java IO中的ByteBuffer，使用文件映射，使用Socket的SENDFILE技术等。

14.微服务怎样理解 与XXX区别你怎么理解（没听过的拓展名词）

15.介绍一下RPC框架 协议头除了请求ID还有啥，版本号是啥，为什么要有这个

RPC框架是一种远程过程调用框架，它可以让不同的计算机程序在不同的机器上进行远程通信和交换数据。在RPC框架中，协议头除了请求ID还可能包含服务名称、方法名称、消息体等信息。版本号通常用来判断请求和响应的匹配程度，防止不兼容的版本之间进行通信。所有这些信息都是为了更好地实现远程方法调用，以便在不同的系统之间进行通信和交互。

16.序列化协议用的啥 为啥不用JDK原生序列化

17.ZooKeeper集群瓶颈的解决

针对ZooKeeper集群的瓶颈问题，可以通过以下方案进行解决：
1.确认瓶颈所在：通过监控分析和性能测试，找出集群中的性能瓶颈所在，比如CPU、内存、网络带宽等。
2.升级硬件：根据瓶颈所在，可以升级到更高配置的硬件，以提升整个集群的性能。
3.增加节点数：适当增加ZooKeeper节点数，以增加服务容量，缩短请求处理时间，提升集群性能。
4.集群分片：将集群按照业务数据分成多个子集群，以提升整体业务处理性能，并对子集群进行负载均衡。
5.优化ZooKeeper配置：调整ZooKeeper的相关参数，比如最大打开文件数、网络模型、内存模型等。
6.增强客户端缓存：通过缓存客户端数据，减少对ZooKeeper的访问请求，提升整体性能。
7.优化ZooKeeper访问方式：合理使用异步API，减少同步等待，提高ZooKeeper的吞吐能力。

18.完整的一个RPC集群应该要提供哪些功能？

一个完整的RPC集群应该提供以下功能：
1.支持远程过程调用(RPC)：集群中的每个节点都可以接收和处理来自其他节点的RPC请求。
2.负载均衡：能够将请求分发到不同的节点上，以便更好地分配工作量和资源。
3.自动故障转移：当一个节点出现故障或失效时，集群应该自动将请求转移到其他可用的节点上。
4.消息传递：节点之间应该能够相互通信，以便共享信息和同步状态。
5.安全性：RPC集群应该提供一些安全机制,保证数据量传输过程中的机密性和完整性，例如SSL/TLS协议、数字证书等。
6.可扩展性：集群应该能够动态地添加或删除节点，以适应不同的工作负载。
7.高可用性：节点应该有冗余配置和备份，以确保在系统故障时仍然可以正常运行。
以上是一个完整的RPC集群应该提供的功能。

19.算法：求根节点到叶子节点数字之和

20.看你学习过ES（ElasticSearch）

21.Kafka、MQ这些用过没，你觉得消息队列主要用来解决什么样的问题

消息队列主要用来解耦系统中不同模块的数据传输和处理过程，降低模块之间的依赖关系，提高系统的可扩展性、可靠性和可维护性。具体来说，消息队列可以解决以下几个方面的问题：
1.异步处理：消息队列可以将数据传输和处理过程异步化，提高系统的并发处理能力和吞吐量。
2.削峰填谷：消息队列可以将瞬时的高峰流量转化为持续的稳定流量，避免服务因突发流量高峰而宕机。
3.解耦处理：消息队列可以将不同模块之间的数据传输和处理过程解耦，降低模块之间的依赖关系，提高系统的可维护性和可扩展性。
4.数据分发：消息队列可以将数据分发到多个消费者中，支持多种业务场景的实现。例如，任务分发、日志收集、消息推送等。
5.消息重试：消息队列中未被成功消费的消息可以被重新消费，提高数据传输的可靠性。

美团二面（一小时15分钟）

22.给定一个数组和一个值k，k是滑动窗口的长度，求窗口滑动过程中的中位数，返回中位数数组

知乎（面试中）

知乎一面（40分钟）

1.说说字节实习经历 为什么用clickhouse倒排索引原因? hive和clickhouse分别的适用场景?

clickhouse是一个高性能的列式存储数据库，适合处理大规模数据，特别是面向OLAP场景，而Hive则更适合用于面向数据仓库的批处理作业。倒排索引是clickhouse的一个优势，它能够快速地查找出包含指定关键字的所有文档。根据具体业务场景的不同，可以根据需求灵活选择使用hive或clickhouse。

2.你们的这个项目是交由广告主来筛选标签确定目标用户，为什么不由平台来做这件事，了解产品本身出发来给标签用户推荐 然后问和“啤酒和尿布的故事”类似的XXX算法了解吗

3.你理解的Java和Go的区别 Go为什么并发安全 什么情况下会出现并发不安全

4.协程、线程、进程的区别 为什么协程切换开销更小

5.点击知乎网址到页面渲染的过程 TCP和HTTP的区别 HTTP常见状态码 重定向怎么实现的

6.做题：大数相加

快手-商业化（三面挂）

一面 + 二面（各一小时）

1.Java类加载过程，static变量在哪个阶段赋值的，常量在哪个阶段赋值的原因

Java类加载过程可以分为加载、验证、准备、解析和初始化五个步骤。其中，静态变量在类加载的准备阶段被赋上初始值（默认值），常量在编译期就被赋值并存储在常量池中，所以在加载阶段就已经被赋上了初值，不需要等到准备阶段。这样设计的原因是为了提高运行时的效率。

2.HashMap线程安全吗？底层结构是什么？ CurrentHashMap实现是什么？ CAS是啥？ ABA问题是什么？ JDK8以前解决hash冲突为什么要头插？

HashMap并不是线程安全的，因为在并发环境下多个线程可以同时修改HashMap导致数据不一致。HashMap的底层结构是数组+链表（数组中的每个元素存储链表的头结点），用于存储键值对。ConcurrentHashMap的实现采用的是分段锁的方式，将数据分成多个Segment（默认为16个），每个Segment都有自己的锁，不同线程可以同时访问不同的Segment，从而提高并发性能。CAS（Compare And Swap）是一种非阻塞算法，用于实现并发操作。ABA问题是指在利用CAS进行线程安全操作时，可能会出现一个值从A变为B再变回A的情况，导致操作结果出现异常。JDK8以前解决hash冲突要头插是因为此时该元素会成为链表的头节点，可以提高查找效率。

3.Synchronized原理， 锁升级原理是什么？

Synchronized关键字是Java中用于线程同步的一种方式，可以将多个线程对共享资源的访问串行化，保证线程安全。当一个线程进入Synchronized代码块时，它会尝试获取锁，如果锁已经被其他线程占用，那么当前线程就会被阻塞等待获取锁。在Java虚拟机中，Synchronized锁的实现采用的是管程（Monitor）技术。
锁升级是指当一个线程持有了偏向锁（Bias Lock）或轻量级锁（Lightweight Lock）后，如果发现有其他线程也想访问这个锁，就会将锁升级为重量级锁（Heavyweight Lock），具体实现是通过将锁对象的Mark Word替换为指向重量级锁的指针。锁升级的目的是为了减少锁的粒度，避免频繁地进行锁竞争，提高程序的并发性能。

4.怎样实现一个redis分布式锁

要实现一个redis分布式锁，首先需要在redis中设置一个键为锁的名称，然后给锁设置一个超时时间。接着，每个客户端在尝试获取锁时，需要通过SETNX命令对这个键进行操作，如果这个键对应的值不存在，则说明当前客户端获取到了锁，否则说明当前锁被其他客户端占用，当前客户端需要等待一段时间之后再次尝试获取锁。
在释放锁时，需要使用一个类似于Lua脚本的命令来判断锁是否已经被其他客户端占用，如果锁没有被占用，则通过DEL命令删除当前锁的名称，释放锁。如果锁被其他客户端占用，则需要等待一段时间再次尝试释放锁。
需要注意的是，在实现redis分布式锁时，需要考虑到网络延迟和并发访问等因素，尽可能地提高锁的可用性和稳定性。

5.为什么用缓存，除了考虑数据查询效率更高外还有其他的原因吗？

使用缓存不仅可以提高数据查询效率，还可以减轻服务器负载，节省带宽和服务器资源。当客户端请求某个数据时，服务器可以将该数据缓存起来，如果其他客户端需要访问同样的数据，服务器可以直接从缓存中获取，而不需要重新查询数据库。这样可以减少数据库查询的次数，降低服务器的负载，从而提高系统的性能。另外，使用缓存还可以提高网页的加载速度，提升用户体验。

6.MySQL事务命令？ MySQL的隔离级别有什么？会出现幻读问题吗？间隙锁算法是啥？ 什么情况下锁级别会到表锁级别？什么时候加上间隙锁？

MySQL事务命令包括BEGIN、COMMIT和ROLLBACK。MySQL的隔离级别有READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ和SERIALIZABLE。会出现幻读问题，即多次读取数据时，可能会出现新增的行或者被删除的行。间隙锁算法是为了避免幻读问题而设计的，用于锁定数据行之间的间隙，防止出现新插入的行。锁级别会到表锁级别的情况，比如出现全表扫描、group by和order by语句等操作时。加上间隙锁的情况，一般是在使用高并发的情况下，为了避免幻读问题而加上间隙锁。

7.Redis数据结构？ map底层实现？什么时候压缩列表什么时候哈希表？

Redis数据结构包括：字符串(string)、哈希表(hash)、列表(list)、集合(set)、有序集合(sorted set)。Map底层实现一般使用哈希表，在键比较小的时候使用压缩列表，可以占用更少的空间。具体来说，当一个列表中存储的所有元素的长度都小于64字节，并且这个列表中元素个数小于512个时，Redis就会使用压缩列表来实现列表结构。但当有新元素要加入到列表中，而此时列表中已有元素个数超过了512时，Redis就会将压缩列表转化为常规列表，也即是基于链表实现的列表结构。
而哈希表则是一种更加通用的底层实现，哈希表可以支持更大的键值对数量，同时也可以提供更高效的访问速度，因此哈希表成为了Redis的默认底层实现方式。

8.Redis持久化方案 ？Redis持集群是怎样的？Cluster集群将存储空间分成了多少份？

关于Redis持久化方案，Redis提供了两种持久化方案：RDB和AOF。其中RDB是将内存中的数据按照一定的数据结构格式写入到硬盘中，而AOF则是将Redis执行的每一次写操作以追加的方式写入到硬盘中。这两种方案各有优缺点，可以根据不同应用场景进行选择。
对于Redis集群，其采用的是Cluster集群方案。Cluster集群将整个数据集分成固定数量的16384个槽，并将这些槽均匀分配到不同的节点上。每个节点都负责一部分槽的数据存储和操作，并且节点之间也会进行数据同步和状态维护，从而实现了数据的高可用和分布式处理。

9.TCP粘包和拆包问题怎么解决

TCP粘包和拆包问题的解决方法主要有以下几种：
1.使用固定长度的消息：将消息按照固定长度分割，然后发送。
2.向消息中添加消息边界：消息中添加特定的分隔符，例如"\n"，然后在接收端读取时按照分隔符进行拆包。
3.在消息中添加消息长度：发送方在消息头中添加消息的长度，接收方先读取消息头中的长度信息，然后按照长度读取消息。
4.使用应用层协议：应用层协议可以定义消息的格式和数据结构，例如HTTP、SMTP等。
需要根据具体场景进行选择和实现，以保证数据的正确传输和解析。

10.AQS实现原理 公平锁和非公平锁怎么做到的

AQS（AbstractQueuedSynchronizer）是Java并发包中的一个抽象类，其主要作用是提供了一种实现同步器的框架，具体的同步器可以通过继承AQS来实现。AQS使用一个FIFO双向队列进行线程的排队等待，实现了一个线程安全的锁的机制。
公平锁和非公平锁的实现方式不同。在公平锁中，等待锁的线程按照先来先服务的原则排队，当锁被释放时，队列中的第一个等待线程会获得锁。而在非公平锁中，等待锁的线程会直接尝试获取锁，如果锁没有被占用，则可以直接获取到锁，否则就会进入等待队列。
为了实现公平锁，AQS中使用了一个FIFO队列来存放等待锁的线程，并且确保锁的获取顺序与线程等待队列中的顺序一致。而在非公平锁中，线程直接尝试获取锁，不需要进入等待队列，所以不需要考虑队列的顺序。

11.Redis的发布-订阅模式怎么做的 为什么用JDK动态代理 RPC协议头设计 消息总线最终一致性

Redis的发布-订阅模式是通过多个客户端与Redis建立连接后，订阅一个或多个频道，当发布者发布消息到被订阅的频道时，Redis会转发消息给所有订阅者。可以通过执行PUBLISH命令来发布消息，执行SUBSCRIBE命令来订阅频道。
JDK动态代理是通过在运行时生成一个代理类来完成对目标对象的代理，只需要实现InvocationHandler接口并重写invoke()方法即可。RPC协议头设计需要考虑协议版本，序列化方式，消息长度等，通过使用协议头来描述消息的结构和属性。消息总线最终一致性是指在分布式环境下，通过异步通信模型来保证不同节点间消息的最终一致性，可以通过消息队列来实现。

12.OLAP和OLTP的适用场景分别是？哪些数据库通常用作OLTP查询？除了Clickhouse还有那些其他列式数据库？ clickhouse架构什么？

OLAP和OLTP的适用场景分别是不同的。OLAP通常用于大型数据集和复杂查询的场景，如数据仓库和商业智能分析。而OLTP则用于处理实时交易和操作型数据的场景，如在线零售、银行和物流等领域。
通常，许多关系型数据库如MySQL、Oracle等都适用于OLTP查询。此外，还有一些专门的列式数据库，如Vertica、Greenplum和Infobright等。
除了Clickhouse之外，其他一些列式数据库包括Apache Cassandra、Apache Hbase、Amazon Redshift等等。
Clickhouse架构是一个高度并行的分布式系统，由若干个节点组成。其中有一些节点作为分布式计算节点，其他节点则为存储节点，数据在这些存储节点之间进行水平切分。Clickhouse的架构使其能够处理PB级别的数据规模和非常复杂的查询。

13.考察数据结构的场景设计：网页的前进和回退实现，一个栈够吗？什么时候栈满，最多回退几次？

对于网页的前进和回退操作，使用一个栈是可以实现的。当用户点击前进按钮时，将当前URL地址入栈；当用户点击回退按钮时，将栈顶的URL出栈，并在浏览器中显示栈顶URL对应的网页。当栈满时，最多能回退的次数取决于栈的大小，一般情况下，推荐栈大小为10或者20。

14.算法题一二面各出了一道：二叉树的最大路径和 合并N个有序链表

三面（一小时）

15.算法题优化：找到一个数组里的众数集合（存在多个众数） 要求将时间复杂度从O(3n)、O(2n)逐步优化到O(n)，空间复杂度尽可能小

16.Java集合接口有哪些？List和Map的扩容机制是什么？

Java集合接口包括List、Set、Queue、Deque和Map等。
List的扩容机制是当元素数量超过当前容量时，会分配一个原来容量的1.5倍大小的新数组，并将原数组中的元素复制到新数组中。Map的扩容机制是当元素数量超过负载因子与容量的乘积时，会将容量扩大为原来的2倍，并将所有元素重新分布到新的桶中。

去哪儿旅行（已offer）

一面（40分钟）

1.TCP报文结构是什么？ 可靠传输原理实现是什么？ TCP连接为什么是三次握手？

TCP报文结构包括：TCP头和TCP数据。TCP头包括源端口号、目的端口号、序列号、确认号、数据偏移量、保留位、控制位、窗口大小、校验和和紧急指针等字段。TCP数据则是应用层传输的数据。
可靠传输原理是通过序列号和确认号实现的。发送方为每个数据段编号，接收方收到数据后发送确认消息，确认消息中包含了确认号，表示接收方期望接收下一个数据段的序号。如果发送方没有收到确认消息，就会重传数据段，直到接收方发送了确认消息。
TCP连接采用三次握手的原因是为了保证双方都能正确地收到对方的数据。第一次握手是客户端向服务器发送连接请求，第二次握手是服务器接收到请求并回复确认消息，第三次握手是客户端接收到确认消息并发送确认回复。这样双方都确认了对方的可达性和可靠性，建立了可靠的连接。如果只有两次握手，由于网络延迟等问题，可能会导致客户端发送的连接请求丢失，而服务器不知道客户端的意图，从而产生问题。

2.Java对象组成有哪些？ new一个Object对象占多少字节？

Java对象由对象头、实例数据和对齐填充三部分组成。对象头用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志等。实例数据则是对象真正存储的数据，包括类的字段和实现继承的字段。对齐填充则是为了满足JVM的内存对齐要求而添加的填充字节，以保证对象占用的内存大小是8字节的倍数。
对于一个普通的Object对象，其对象头大小为8字节，实例数据为0字节，对齐填充为0字节，因此它占用的内存大小为8字节。但是需要注意的是，实际上JVM在分配内存时可能会进行一些优化，如对象的大小小于一定的阈值时，可能会直接使用TLAB（Thread Local Allocation Buffer）分配内存，此时对象的占用内存大小可能会略微不同。

3.HTTP状态码 301、 302 区别？ 重定向和转发过程的区别？

HTTP状态码301和302都代表重定向，但它们的含义和使用场景是不同的。
301状态码表示永久重定向，当客户端访问某个URL时，服务器会返回301状态码和新的URL，客户端会自动重定向到新的URL，以后访问该URL都会直接访问新的URL。301状态码主要用于网站URL更改后的重定向。
302状态码表示临时重定向，客户端访问某个URL时，服务器会返回302状态码和新的URL，客户端会自动重定向到新的URL，但以后访问该URL仍然会访问原来的URL。302状态码主要用于临时性重定向，例如网站正在维护时，暂时将访问URL重定向到另一个URL上。
重定向和转发都是HTTP协议中的概念，但它们的实现方式和作用不同。
重定向是指客户端请求一个URL时，服务器返回一个状态码和新的URL，客户端会自动跳转到新的URL。重定向会增加HTTP请求次数，影响网站性能，但可以使客户端直接访问到正确的URL。
转发是指客户端请求一个URL时，服务器不返回状态码和新的URL，而是将请求转发给另一个URL，客户端不会发生跳转。转发不会增加HTTP请求次数，但客户端无法知道实际访问的URL是哪一个。转发通常用于网站内部的URL跳转。

4.Synchronized可以用在哪里？ 实现原理是什么？ 锁升级过程？ Synchronized与Lock锁区别在哪？

Synchronized 是 Java 中的关键字，它可以用来实现线程间的同步。它可以用在方法上或代码块中，并且只能锁住对象。实现原理是使用对象头中的标志位来实现锁的获取和释放。当一个线程进入 synchronized 代码块时，会尝试获取对象锁，如果锁没有被占用，则获取锁成功并继续执行代码块，否则线程进入阻塞等待状态。
锁升级过程是指 synchronized 锁的状态从无锁到偏向锁，再到轻量级锁，最后到重量级锁的过程。在 Java 6 中，引入了偏向锁，它可以在无竞争的情况下减少同步的开销。在 Java 6 之后，还引入了轻量级锁和重量级锁，它们的实现都是基于 CAS 和自旋等技术。
Synchronized 和 Lock 锁的区别在于，Synchronized 是 Java 中的关键字，而 Lock 是一个接口，需要通过实现类来使用。Synchronized 只能锁住对象，而 Lock 锁可以锁住任何对象。Synchronized 的使用非常方便，但是在某些情况下会影响程序的性能，而 Lock 锁的使用可以更加灵活，但需要手动加锁和释放锁，使用起来相对复杂一些。同时，Lock 锁可以实现公平锁和非公平锁，而 Synchronized 只能实现非公平锁。

5.CAS是啥？ 可能存在什么问题？

CAS是指“比较和交换（Compare And Swap）”，是一种在多线程编程中用于实现同步的原子操作。它通常用于实现锁和并发数据结构，保证多个线程同时对同一个共享变量进行读写时的正确性和一致性。
CAS的一个潜在问题是ABA问题。ABA问题指的是当一个值在被读取之后被改变为另一个值，然后又被改回原来的值时，CAS操作会误认为该值没有被改变过，从而可能导致程序逻辑错误。为避免ABA问题，可以使用带有版本号的CAS操作，或者采用其他同步机制，如锁等。

6.阻塞一个线程有哪些方法？

阻塞一个线程有以下几种方法：
1.调用 Thread.sleep() 方法，使线程休眠一段时间，直到时间结束或者被中断。
2.调用 Object.wait() 方法，使线程等待直到被唤醒或者中断。
3.调用 Thread.join() 方法，等待另一个线程执行完毕。
4.调用 Lock.lock() 方法，使线程获得锁并进入等待状态，直到其他线程释放锁。
5.调用 Semaphore.acquire() 方法，使线程等待直到获得信号量。
6.调用 CountDownLatch.await() 方法，使线程等待直到计数器为 0。
7.调用 CyclicBarrier.await() 方法，使线程等待直到所有线程都到达屏障。
这些方法都可以使线程进入阻塞状态，等待某个条件满足或者被唤醒。

7.创建线程的方式？ 线程池工作原理 ？线程池拒绝策略？

创建线程的方式有三种，分别为继承Thread类、实现Runnable接口和使用线程池。
线程池工作原理：线程池是一种预先创建一定数量的线程，并将它们保存在一个线程池中，等待分配任务并执行。线程池通过控制线程的数量和重复利用已创建的线程来优化系统性能和资源消耗。当一个任务到达线程池时，线程池中的一个线程会被分配给这个任务进行处理。当这个任务完成之后，该线程不会被销毁，而是继续等待执行下一个任务。这样，线程池就可以避免频繁地创建和销毁线程，从而提高系统的性能。
线程池拒绝策略：当线程池中的线程数量达到设定的最大值，并且任务队列中的任务也已满时，新来的任务就会被拒绝执行。此时，线程池需要采取一些拒绝策略来处理这些任务。常见的拒绝策略有以下几种：
1.AbortPolicy：默认的拒绝策略，直接抛出RejectedExecutionException异常。
2.CallerRunsPolicy：在当前线程中执行任务。这样做的好处是可以避免任务的丢失，但是会影响当前线程的性能。
3.DiscardPolicy：直接丢弃任务，不做任何处理。
4.DiscardOldestPolicy：丢弃队列中最早的任务，然后尝试重新提交新的任务。

8.分布式ID怎么选？集群节点间通信是如何进行的？

选择分布式ID生成方案时，需要考虑以下几个因素：
1.唯一性：生成的ID必须是唯一的，不能重复。
2.可读性：ID最好有一定的可读性，方便人工查看和调试。
3.可扩展性：ID生成方案需要支持水平扩展，以满足业务的高并发和高吞吐的需求。
4.性能：生成ID的性能需求要求较高，不能成为系统的瓶颈。
集群节点间通信可以通过以下几种方式进行：
1.TCP/IP协议：集群中的节点可以通过TCP/IP协议进行通信，常用的TCP/IP框架有Netty和Mina等。
2.HTTP协议：集群中的节点可以通过HTTP协议进行通信，常用的HTTP框架有Spring MVC和Struts2等。
3.RPC框架：集群中的节点可以通过RPC框架进行通信，常用的RPC框架有Dubbo和gRPC等。
4.消息队列：集群中的节点可以通过消息队列进行通信，常用的消息队列有ActiveMQ和RabbitMQ等。

9.RPC原理？RPC与其他RPC框架相比，优势和不足是什么 ？

RPC（Remote Procedure Call）远程过程调用是一种计算机通信协议，它允许一个程序在另一个地址空间中执行一个子程序，并且不需要程序员显式地编写远程调用的代码。RPC框架通常由客户端和服务器端组成，客户端发起一个远程调用请求，服务器端接收请求并响应，然后客户端再接收响应结果。RPC的实现方式很多，包括基于HTTP协议的RESTful API、基于TCP/IP协议的Thrift、gRPC等。
与其他RPC框架相比，RPC框架的优势主要有以下几点：
1.简单易用：RPC框架的API设计比较简单，使用起来也比较方便，可以快速开发出一个分布式应用。
2.跨语言支持：RPC框架可以支持多种编程语言，比如Java、Python、Go等，可以方便地实现跨语言调用。
3.高效性：RPC框架的通信协议通常是二进制协议，与HTTP相比，数据量更小，传输速度更快。
4.可扩展性：RPC框架可以支持多种序列化和压缩算法，可以根据实际情况进行配置和调整。
不足之处：
1.依赖性：RPC框架需要客户端和服务器端都使用框架提供的API，这样会带来一定的依赖性。
2.复杂性：RPC框架需要处理很多细节问题，比如协议、序列化、负载均衡等，这些问题需要开发者花费一定的时间和精力去处理。
3.性能问题：RPC框架的性能通常比纯TCP/IP协议差一些，因为需要进行一些额外的处理，比如序列化和反序列化等。
总的来说，RPC框架是一种分布式应用开发的重要工具，它可以大大简化分布式应用的开发和维护。但是在使用RPC框架时，需要注意其依赖性和复杂性，同时需要根据实际情况进行性能调优。

10.动态代理技术选型怎么考虑的？

在进行动态代理技术选型时，应该考虑以下因素：
1.需求场景：首先需要明确代理要解决的问题，例如增加安全性、性能优化、业务逻辑增强等，不同的需求场景可能需要不同的代理技术。
2.技术特点：不同的动态代理技术有不同的技术特点，例如 JDK 动态代理只能代理实现了接口的类，而 CGLib 可以代理没有实现接口的类，需要根据技术特点选择合适的技术。
3.性能表现：动态代理技术会带来额外的性能消耗，在选型时需要考虑代理的频率、代理对象的数量等因素，选择性能更好的代理技术。
4.可维护性：动态代理技术的实现方式不同，对代码的可维护性也会有影响。需要选择易于维护、扩展性好的代理技术。
5.生态支持：常用的动态代理技术应该有完善的生态支持，例如文档、案例、社区等，方便开发者解决问题和学习。

11.介绍下即时通讯项目

12.websocket与HTTP区别？

WebSocket和HTTP都是应用层协议，但它们之间有几个重要的区别：
1.HTTP是一种无状态协议，每个请求都是独立的，没有上下文关联。而WebSocket是一种有状态协议，建立连接后可以保持连接状态，并在连接的生命周期内收发多个消息。
2.HTTP协议采用的是请求-响应模式，客户端向服务器发送请求并等待响应后才能发送下一个请求。而WebSocket是双向通信的，客户端和服务器可以同时发送和接收消息。
3.HTTP协议采用明文传输，安全性较低，需要通过HTTPS进行加密。而WebSocket可以使用WSS协议进行加密传输，安全性较高。
4.WebSocket通信的开销较小，协议头只有2个字节，而HTTP协议头较大，每次请求的头部信息都会占用很多带宽。
总之，WebSocket适用于需要频繁、实时地收发消息的应用程序，而HTTP适用于请求响应模式的传输。

13.分布式系统设计要解决哪些点

设计分布式系统时需要考虑以下几个关键问题：
1.数据一致性：如何确保在分布式系统中所有的节点访问和修改数据时保持数据一致性。
2.容错性：如何处理节点失效或网络故障等异常情况，确保系统能够持续运行。
3.可扩展性：如何支持系统的水平扩展，以满足不断增长的用户需求。
4.性能：如何提高系统的吞吐量和响应时间，以满足用户的实时需求。
5.安全性：如何保护系统的数据和资源，防止黑客攻击和数据泄露等安全问题。
这些问题都是设计分布式系统时必须要考虑的关键因素，需要根据具体的应用场景和需求进行综合权衡和优化。

14.算法：手写生产者消费者模型

六、京东Java后端实习面经

1.Java的祖先类

Java的祖先类是Object类。所有Java类都继承自Object类，如果一个类没有显式地继承某个类，那么它默认继承自Object类。

2.Object类有哪些方法

Object类中定义了一些基本的方法，比如toString()、hashCode()、equals()等，因此所有Java类都具有这些方法。

3.Java中的集合

Java中的集合是一种用来存储一组对象的容器。Java集合框架提供了多种集合类型，包括List、Set、Map等。其中，List可以存储有序的元素，可以允许元素重复；Set可以存储无序的元素，不允许元素重复；Map可以存储键值对，用于快速查找元素。Java集合框架提供了丰富的API，可以进行添加、删除、查找、排序等操作。常用的集合类有ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。

4.比较ArrayList和LinkedList

ArrayList和LinkedList都是Java集合框架中的List接口的实现类，它们的主要区别在于内部实现方式和性能表现。
ArrayList内部是通过一个可变的数组来实现的，因此支持随机访问，可以快速地通过下标访问元素，但是插入和删除操作可能会比较慢，因为需要移动元素。
LinkedList内部是通过一个双向链表来实现的，因此支持插入和删除操作，可以快速地在任意位置插入和删除元素，但是随机访问元素可能会比较慢，因为需要遍历链表来查找元素。
因此，如果需要频繁地进行随机访问操作，建议使用ArrayList；如果需要频繁地进行插入和删除操作，建议使用LinkedList。但是需要注意的是，LinkedList的空间开销比ArrayList要大，因为需要为每个节点保存指针信息。

5.ArrayList和LinkedList它们是线程安全吗？为什么

ArrayList和LinkedList都不是线程安全的，因为它们都不是设计为多线程环境中使用的。多线程环境下，多个线程可能同时对同一个ArrayList或LinkedList进行读写操作，这样就会导致数据不一致的问题。如果需要在多线程环境中使用列表，可以使用线程安全的Vector或者CopyOnWriteArrayList。

6.写sql：学号、姓名、科目、成绩4个字段，查找所有科目总成绩大于10的学生学号、姓名和总成绩

SELECT 学号, 姓名, SUM(成绩) AS 总成绩
FROM 表名
GROUP BY 学号, 姓名
HAVING SUM(成绩) > 10;

7.线程池的工作原理

线程池是一种常见的多线程处理方式，它可以有效地管理和重用线程，提高并发处理能力和资源利用率。线程池的工作原理如下：
1.初始化线程池：创建一定数量的线程，存储在任务队列中等待任务的到来。
2.接收任务：当有任务到来时，线程池会从任务队列中取出一个线程来执行该任务。
3.执行任务：线程池将任务分配给空闲的线程，线程执行完任务后，将结果返回给线程池。
4.返回结果：线程池将任务的执行结果返回给任务提交者。
5.重复执行：线程执行完任务后，会检查是否有新的任务需要执行，如果有，继续执行任务，否则线程将回到任务队列中等待下一个任务。
线程池的主要优点是可以减少线程的创建和销毁，避免了线程频繁创建和销毁所带来的性能开销，同时也能够控制线程的数量，避免线程过多导致系统资源的浪费和竞争。

七、快手基础技术部暑期实习java

1.quartz是什么？quartz原理是什么？

Quartz是一个开源的作业调度框架，可以用于在Java应用程序中调度作业执行。Quartz可以让开发人员编写简单的调度程序，而无需考虑底层的调度机制。它支持循环、延迟、定时等多种作业调度方式，并且可以与多种数据存储（如数据库、文件等）进行集成。
Quartz的原理是通过一个调度器（Scheduler）来管理多个作业（Job），每个作业可以包含多个触发器（Trigger），当触发器的条件满足时，对应的作业就会被调度执行。在Quartz中，调度器是单例的，作业和触发器可以动态地添加和删除。Quartz还提供了可靠性、容错性等特性，确保作业能够按照预期执行。

2.问了ES，都是很笼统的问题。围绕项目

3.ES字典树怎么实现的，怎么用

ES字典树是一种高效的字符串匹配算法，它能够在O(m)的时间复杂度内查找所有以某个字符串为前缀的单词。ES字典树的实现方式是将所有字符串以前缀树的形式插入到一棵树中，每个节点表示一个字符串的前缀，从根节点到叶子节点表示一个完整的字符串。
ES字典树的使用通常包括以下几个步骤：
1.构建字典树：将所有需要匹配的字符串插入到字典树中。插入时，从根节点开始，依次查找每个字符所对应的子节点，如果子节点不存在，则创建一个新的子节点，直到插入完整个字符串。
2.查找：从根节点开始依次查找目标字符串中的每个字符所对应的子节点，如果某个字符对应的子节点不存在，则说明目标字符串不存在于字典树中；如果查找完整个目标字符串以后，当前的节点存在一个标记，说明该节点对应的字符串是一个匹配的字符串。
3.删除：从字典树中删除某个字符串，可以将该字符串对应的叶子节点标记为不存在，然后从该节点开始向上回溯，如果发现某个节点的所有子节点都不存在，就可以将该节点删除。
ES字典树的实现方式有很多种，常见的包括基于数组和基于链表的实现方式。其中基于数组的实现方式比较简单，但是需要预先确定字典中最长字符串的长度，空间复杂度较高；基于链表的实现方式不需要预先确定最长字符串的长度，但是增加和删除节点的操作比较复杂，时间复杂度较高。

4.Java中有哪些设计模式

Java中常见的设计模式包括：
1.工厂模式（Factory Pattern）
2.单例模式（Singleton Pattern）
3.原型模式（Prototype Pattern）
4.建造者模式（Builder Pattern）
5.适配器模式（Adapter Pattern）
6.桥接模式（Bridge Pattern）
7.装饰器模式（Decorator Pattern）
8.外观模式（Facade Pattern）
9.享元模式（Flyweight Pattern）
10.组合模式（Composite Pattern）
11.代理模式（Proxy Pattern）
12.模板方法模式（Template Method Pattern）
13.策略模式（Strategy Pattern）
14命令模式（Command Pattern）
15.职责链模式（Chain of Responsibility Pattern）
16.状态模式（State Pattern）
17.观察者模式（Observer Pattern）
18.中介者模式（Mediator Pattern）
19.迭代器模式（Iterator Pattern）
20.访问者模式（Visitor Pattern

5.redis的使用场景？描述一下redis的基本数据类型和使用场景？

Redis是一个开源的内存数据存储系统，提供了键值对存储、发布/订阅、脚本处理等功能。Redis的使用场景非常广泛，包括但不限于以下几个方面：
1.缓存：由于Redis将数据存储在内存中，它的读写速度非常快，因此可以用作缓存，缓解数据库的压力，提高网站的访问速度和并发能力。
2.分布式锁：Redis支持分布式锁的实现，可以用来解决分布式系统中的并发问题。
3.计数器：Redis可以实现高效的计数器，用于统计网站的访问量、在线用户数等。
4.消息队列：Redis的发布/订阅功能可以用于实现简单的消息队列，用于异步处理任务等。
Redis的基本数据类型包括字符串、哈希表、列表、集合和有序集合。它们的使用场景分别如下：
1.字符串：用于存储单个的值，例如用户的会话信息、计数器等。
2.哈希表：用于存储一组键值对，例如用户的个人信息、商品的详细信息等。
3.列表：用于存储一组有序的元素，例如消息队列、最近访问的商品列表等。
4.集合：用于存储一组无序的元素，例如用户的好友列表、商品的标签等。
5.有序集合：用于存储一组有序的元素，每个元素都有一个分值，例如排行榜、热门文章列表等。

八、海康威视java面经

1.讲一下序列化是什么

序列化： 将数据结构或对象转换成二进制字节流的过程。序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程 （补充：对于不想进行序列化的变量，使用 transient 关键字修饰。transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。）常见的序列化格式包括JSON、XML、Protocol Buffers等。

2.java怎么解析xml报文的

Java提供了多种解析XML报文的方式，其中常用的有以下三种：
1.DOM（文档对象模型）解析：将整个XML文档解析成一个树形结构，通过对节点的遍历和操作来读取或修改XML文档。
2.SAX（简单API for XML）解析：采用事件驱动的方式解析XML文档，遍历XML文档时只会处理当前节点，对于非当前节点的内容不会进行处理，具有解析速度快、内存占用少的优点。
3.JAXB（Java Architecture for XML Binding）解析：通过Java对象与XML文档之间的映射，将Java对象转换为XML文档或将XML文档转换为Java对象，使得XML文档的读取和修改更加方便。
在实际开发中，可以根据需求选择适合的解析方式。

3.mysql优化？

1、避免全表扫描，首先考虑在where及order by的列上建立索引。
2、尽量避免在where子句中使用!=或<>操作符， MySQL只有对以下操作符才使用索引：<，<=，=，>，>=，BETWEEN，IN，以及某些时候的LIKE。
3、尽量避免在where子句中使用or来连接条件， 否则将导致引擎放弃使用索引而进行全表扫描， 可以使用UNION合并查询。
4、in和not in也要慎用，否则会导致全表扫描，对于连续的数值，能用between就不要用in了。
5、如果在where子句中使用参数，也会导致全表扫描。
6、尽量避免在where子句中对字段进行表达式操作，应尽量避免在where子句中对字段进行函数操作。
7、索引虽然可以提高相应的select的效率，但同时也降低了insert及update的效率，因为insert或update时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。
8、尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。
9、尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。
10、常见的简化规则如下：不要有超过5个以上的表连接(JOIN)，考虑使用临时表或表变量存放中间结果。少用子查询，视图嵌套不要过深,一般视图嵌套不要超过2个为宜。
11、用OR的字句可以分解成多个查询，并且通过UNION 连接多个查询。他们的速度只同是否使用索引有关,如果查询需要用到联合索引，用UNION ALL执行的效率更高. 多个OR的字句没有用到索引，改写成UNION的形式再试图与索引匹配。一个关键的问题是否用到索引。
12、尽量使用“>=”，不要使用“>”。
13、尽量使用exists代替select count(1)来判断是否存在记录，count函数只有在统计表中所有行数时使用，而且count(1)比count(*)更有效率。
14、sql语句用大写，因为oracle 总是先解析sql语句，把小写的字母转换成大写的再执行。
15、别名的使用，别名是大型数据库的应用技巧，就是表名、列名在查询中以一个字母为别名，查询速度要比建连接表快1.5倍。
16、避免死锁，在你的存储过程和触发器中访问同一个表时总是以相同的顺序;事务应经可能地缩短，在一个事务中应尽可能减少涉及到的数据量;永远不要在事务中等待用户输入。
17、MySQL查询可以启用高速查询缓存。这是提高数据库性能的有效Mysql优化方法之一。当同一个查询被执行多次时，从缓存中提取数据和直接从数据库中返回数据快很多。
18、任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

4.mysql优化的效果怎么查看？

MySQL优化效果的主要指标是查询性能的提升。可以通过以下几个途径来查看优化效果：
1.使用EXPLAIN命令查看查询执行计划，了解查询是否使用了索引、是否存在全表扫描等，从而评估优化效果。
2.使用SHOW STATUS命令查看MySQL运行状态，关注Innodb_buffer_pool_read_requests、Innodb_buffer_pool_reads、Handler_read_rnd_next、Handler_read_first、Com_select等指标，以及执行查询的时间等综合指标，从而评估优化效果。
3.使用慢查询日志功能记录下慢查询的SQL语句，通过分析慢查询日志，了解查询的执行时间、扫描行数、扫描类型等信息，从而评估优化效果。
4.使用性能测试工具（如sysbench、tpcc-mysql等）模拟高并发场景，对比优化前后的吞吐量、响应时间等指标，从而评估优化效果。

5.发送报文后网线被拔掉了会发生什么？

针对这个问题，要分场景来讨论： 拔掉网线后，有数据传输；拔掉网线后，没有数据传输；
拔掉网线后，有数据传输 在客户端拔掉网线后，服务端向客户端发送的数据报文会得不到任何的响应，在等待一定时长后，服务端就会触发超时重传机制，重传未得到响应的数据报文。如果在服务端重传报文的过程中，客户端刚好把网线插回去了。由于拔掉网线并不会改变客户端的 TCP 连接状态，并且还是处于 ESTABLISHED 状态，所以这时客户端是可以正常接收服务端发来的数据报文的，然后客户端就会回 ACK 响应报文。此时，客户端和服务端的 TCP 连接依然存在的，就感觉什么事情都没有发生。但如果如果在服务端重传报文的过程中，客户端一直没有将网线插回去。服务端超时重传报文的次数达到一定阈值后，内核就会判定出该 TCP 有问题，然后通过 Socket 接口告诉应用程序该 TCP 连接出问题了，于是服务端的 TCP 连接就会断开。等客户端插回网线后，如果客户端向服务端发送了数据，由于服务端已经没有与客户端相同四元祖的 TCP 连接了，因此服务端内核就会回复 RST 报文，客户端收到后就会释放该 TCP 连接。此时，客户端和服务端的 TCP 连接都已经断开了。
拔掉网线后，没有数据传输 如果双方都没有开启 TCP keepalive 机制，那么在客户端拔掉网线后，如果客户端一直不插回网线，那么客户端和服务端的 TCP 连接状态将会一直保持存在。如果双方都开启了 TCP keepalive 机制，那么在客户端拔掉网线后，如果客户端一直不插回网线，TCP keepalive 机制会探测到对方的 TCP 连接没有存活，于是就会断开 TCP 连接。而如果在 TCP 探测期间，客户端插回了网线，那么双方原本的TCP 连接还是能正常存在。
KeepAlive机制：当连接超过一段时间没有数据传输之后，TCP自动发送一个数据为空的报文给对方，如果对方回应了这个报文，说明对方还在线，连接可以继续保持，如果对方没有报文返回，并且重试了多次之后则认为连接丢失，没有必要保持连接。

6.java怎么发送http请求？

通过JDK网络类Java.net.HttpURLConnection简介：java.net包下的原生java api提供的http请求
使用步骤： 1、通过统一资源定位器（java.net.URL）获取连接器（java.net.URLConnection）。2、设置请求的参数。3、发送请求。4、以输入流的形式获取返回内容。5、关闭输入流。

7.aop的应用场景有那些？

AOP（面向切面编程）的应用场景包括但不限于以下几个方面：
1.日志记录：记录方法的执行时间、参数、返回值等信息，便于排查问题和性能优化。
2.安全控制：在方法执行前进行身份验证、权限验证等操作，提高系统的安全性。
3.缓存：通过拦截方法，检查缓存中是否有相应数据，避免重复查询数据库，提高系统的性能。
4.事务控制：在方法执行前后进行事务开启、提交或回滚操作，保证数据的一致性和完整性。
5.性能监控：记录方法的调用次数、耗时等信息，分析系统的瓶颈和性能问题。
6.异常处理：捕获方法执行过程中的异常，进行相应的处理，避免系统崩溃。
7.分布式追踪：通过AOP拦截方法，记录方法的调用链路信息，方便进行分布式系统的调试和故障排查。

8.java使用jdbc的顺序：

1):注册驱动 （告诉Java要连接什么数据库）
2): 获得连接 （表示JVM的进程与数据库之间的通道打开）
3): 获得数据库操作对象 （它专门执行sql语句的对象）
4): 执行sql 语句
5): 处理查询结果集 （只有执行select 语句才有的步骤）
6): 释放资源 （使用完后，一定要关闭）

9.观察者模式

观察者模式，也被称为发布订阅模式，是一种行为型设计模式，也是在实际的开发中用得比较多的一种模式，当对象间存在一对多关系时，就可以使用观察者模式。定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象（观察者对象）都得到通知并被自动更新。

10.单例模式

单例模式有以下特点： 单例类只能有一个实例；单例类必须自己创建自己的唯一实例；单例类必须给所有其他对象提供这一实例；
优缺点： 优点：由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统运行效率。缺点：因为系统中只有一个实例，导致了单例类的职责过重，违背了“单一职责原则”，同时不利于扩展。
该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

11.工厂模式

工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式

12.怎么确保多线程的共享变量的可见性

Java中可以通过synchronized、volatile、java.concurrent类来实现共享变量的可见性。

九、中兴java面经

一面凉经：

1.抽象类和接口的差别，使用场景

抽象类要被子类继承，接口要被类实现。
　　接口只能做方法声明，抽象类中可以作方法声明，也可以做方法实现。
　　接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
　　接口是设计的结果，抽象类是重构的结果。
　　抽象类和接口都是用来抽象具体对象的，但是接口的抽象级别最高。
　　抽象类可以有具体的方法和属性，接口只能有抽象方法和不可变常量。
　　抽象类主要用来抽象类别，接口主要用来抽象功能。

2.扩展都是用父类来做吗

在面向对象编程中，扩展可以通过继承父类来实现。子类可以继承父类的属性和方法，并且可以在子类中添加新的属性和方法，从而实现对父类的扩展。除了继承，还可以通过实现接口、组合等方式对类进行扩展。

3.为了避免类太臃肿，用聚合和组合，这两个方式怎么用？

1.聚合（整体和部分可以分开）
　　2.组合（整体和部分不能分开）
　　聚合是一种弱关联关系；组合是一种强关联关系。
　　在聚合关系中的两个类（或实体）的生命周期是不同步；但，在组合关系中的两个类（或实体）的生命周期是同步的。

4.wait和sleep的差异

两者都可以暂停线程的执行。
　　sleep() 方法没有释放锁，而 wait() 方法释放了锁 。
　　wait() 通常被用于线程间交互/通信，sleep()通常被用于暂停执行。
　　sleep() 是 Thread 类的静态本地方法，wait() 则是 Object 类的本地方法。
　　wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify()或者 notifyAll() 方法。sleep()方法执行完成后，线程会自动苏醒，或者也可以使用 wait(long timeout) 超时后线程会自动苏醒。

5.线程自己写过线程池吗

使用线程池的好处：
　　降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
　　提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
　　提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
　　execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
　　submit()方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功。

6.final和abstract能一起用吗

abstract与final不能同时使用，因为abstract的作用是定义抽象方法让子类继承重写的，而final修饰的方法是可以被子类继承但是不能重写。

7.final和abstract这俩关键字是啥？

final和abstract是Java中的关键字。final关键字用于修饰类、方法和变量，表示它们不可被继承、重写或赋值。abstract关键字用于修饰类和方法，表示它们是抽象的，不能被实例化，只能被继承或实现。抽象类中可以有抽象方法和非抽象方法，而实现抽象类的子类必须实现抽象方法。

8.初始化字符串用字面量还是new String（）

初始化字符串时，推荐使用字面量而不是new String()。因为使用字面量可以更简单、更直观地创建字符串，同时也能够避免一些潜在的问题，例如使用new String()会创建新的对象，而使用字面量则会在字符串常量池中查找是否已经存在相同值的字符串，如果存在，则直接返回该字符串的引用，避免了创建不必要的对象。

9.差异在哪

10.字面量的String存在什么问题？

字面量的String存在一个问题是在内存中会产生多个相同的String对象，造成内存浪费。例如，如果在代码中多次使用相同的字符串字面量，每次使用都会创建一个新的String对象，这样会占用大量的内存空间。此外，由于String是不可变的，所以每次对String进行修改时，也会创建一个新的String对象。为了避免这个问题，可以使用StringBuilder或StringBuffer来动态生成String对象。

11.字面量String存在哪个空间？

在Java中，字面量String存在字符串常量池中。字符串常量池是一块特殊的内存空间，用于存储字符串字面量和字符串对象（通过String的构造方法创建的字符串）。当使用字面量赋值给一个字符串变量时，JVM会先在字符串常量池中查找是否存在相同值的字符串，如果存在，则直接返回该字符串的引用，否则在常量池中创建一个新的字符串对象，并返回其引用。由于字符串常量池是在JVM启动时创建的，因此它是全局唯一的，可以被多个字符串对象共享。

12.里式替换、依赖倒置是什么？

里式替换原则（Liskov Substitution Principle，LSP）是指，如果一个函数需要一个基类对象作为参数，那么使用该基类的任何子类对象都应该能够正常地替换掉该基类对象，而不会导致程序出错或产生异常。这就要求子类必须完全符合父类的约束条件，以保证程序的正确性和可靠性。
依赖倒置原则（Dependency Inversion Principle，DIP）是指，高层模块不应该依赖于低层模块，它们都应该依赖于抽象接口；抽象接口不应该依赖于具体实现，而具体实现应该依赖于抽象接口。这就要求我们在设计系统时，应该优先考虑抽象接口，而不是具体实现，以便后续的扩展和维护。

13.框架为什么要设置IOC？目的是什么

框架中设置IOC的目的是为了实现松耦合和可维护性。IOC（Inversion of Control）即控制反转，是一种设计模式，将对象的创建、组装和管理交给容器来完成，而不是由对象自己来完成。在传统的开发模式中，对象之间的依赖关系比较紧密，一个对象需要依赖其他对象来完成自己的职责，这样会导致代码之间的耦合度很高，当一个对象需要修改时，会影响到很多其他对象。而使用IOC容器，可以将对象之间的依赖关系解耦，通过容器来管理对象之间的依赖关系，使得对象之间的耦合度降低，代码更加灵活、可维护性更高。

14.框架是怎么实现IOC的？

框架实现 IoC（控制反转）的主要方式是依赖注入（Dependency Injection，简称 DI）。依赖注入是指在对象创建时，将其依赖的其他对象通过构造函数、属性或者参数传递给它，而不是由对象自己去创建或者查找依赖的对象。这样，对象的依赖关系就不再由对象自己管理，而是由 IoC 容器来管理。
IoC 容器是框架中的核心，它负责创建对象、管理对象的生命周期，以及处理对象之间的依赖关系。在框架中，通常会定义一个或多个接口，用来规范对象之间的交互方式。通过这些接口，框架可以更好地控制对象之间的依赖关系，从而实现 IoC。
在使用框架时，我们只需要定义好对象之间的依赖关系，然后将这些对象交给 IoC 容器管理，框架就会自动创建、初始化、销毁对象，并处理对象之间的依赖关系。这样，我们可以更专注于业务逻辑的实现，而不必关心对象的创建和管理。

15.框架的底层实现依赖的是什么？

Spring框架的底层实现依赖的是Java反射机制和Java的动态代理机制。反射机制可以在运行时动态地获取类的信息，实例化对象，调用方法等，而动态代理机制则可以在运行时动态地生成代理类，从而实现AOP编程。这两个机制是Spring框架的核心技术之一，也是Spring框架实现诸多功能的基础。

16.高度是k的二叉树最多有多少节点？

高度为k的二叉树最多有2 ^ (k+1)-1个节点。其中，k表示树的高度，2^(k+1)表示树的叶子节点的数量，减1表示加上根节点的数量。

17.数组和链表的区别？

数组和链表都是数据结构，但它们有很大的不同。
数组是一种线性数据结构，它的元素在内存中是连续存储的。数组的特点是可以随机访问，因为通过下标可以直接计算出元素的内存地址。但是，数组大小固定，不能动态地增加或减少，这就意味着在数组已满时，需要重新分配一块更大的内存，并将原来的元素复制到新的内存中。
链表也是一种线性数据结构，但它的元素在内存中是离散存储的，每个元素包含指向下一个元素的指针。链表的特点是可以动态地增加或减少元素，因为它不需要连续的内存空间。但是，链表不能像数组那样随机访问元素，因为需要从头开始遍历链表，直到找到需要的元素。
综上所述，数组适合于随机访问，但插入和删除元素比较麻烦；链表适合于插入和删除元素，但访问元素比较麻烦。

18.数组和链表在内存开销上的差异？

数组和链表在内存开销上有一些区别。
数组的内存分配是连续的，也就是说，所有的数组元素都在内存中连续的地址上。数组的内存开销较小，因为它只需要分配一段连续的内存空间即可。但是，数组的大小是固定的，如果需要改变数组的大小，需要重新分配内存，这样会很耗费时间和空间。
链表的内存分配是不连续的，每个节点都可以独立地分配内存空间。链表的内存开销较大，因为每个节点都需要分配内存空间，而且每个节点之间的指针也需要占用一定的内存空间。但是，链表的大小可以动态地调整，可以很方便地插入和删除节点。
因此，如果需要经常进行插入和删除操作，链表可能更加适合，如果需要快速访问数组中的元素，则数组更加适合。

19.普通的线性搜索和二分查找的优势？

线性查找可以针对任何数组，将数组中的每项依次遍历出来之后，与所要查找项对比。消耗时间也是不规律的，可能查找项处于数组的第一位，也可能处于数组的最后一位。还有可能数组中完全不存在需要查找的项目。查找时间复杂度为O(n) ，普通的线性搜索适用于小型数据集，它的实现简单，容易理解，不需要数据有序。
　　二分查找法，针对有序数组使用。因为数组已经有序排列，可以通过将数组从中间分割，将中间项与所需查找项对比；然后再根据对比结果，再次向上或者向下，寻找中间项对比，直至完成查找。查找时间复杂度为O(logN)，二分查找适用于大型数据集，它利用了数据有序的特性，可以快速定位到目标元素所在的位置。

十、赛博大象 （ 一点资讯）

1.Redis 缓存热点数据，你如何判断是热点数据呢 ？

判断一个数据是否为热点数据，可以根据它的访问频率和访问时间窗口来确定。一般来说，访问频率高且持续时间长的数据就是热点数据。
在Redis中，可以通过使用命令如KEYS、SCAN、OBJECT等来获取Redis中所有key的访问频率，然后根据访问频率来判断哪些key是热点数据。另外，Redis还提供了一些流行的缓存算法，例如LRU（Least Recently Used）和LFU（Least Frequently Used）等，这些算法可以帮助Redis自动识别和缓存热点数据。

2.使用的数据结构是什么，如何考虑的呢 ， 平时都使用过什么数据结构呢 ？

3.为什么 Redis 快 ？

Redis 之所以快，主要是因为它采用了以下几种优化策略：
1.基于内存：Redis 数据全部存储在内存中，读写速度非常快。
2.单线程：Redis 采用单线程模型，避免了线程切换和竞态条件带来的性能损失。
3.非阻塞 I/O：Redis 采用了非阻塞 I/O，客户端的请求可以异步地处理，节约了等待时间。
4.多路复用：Redis 采用了多路复用技术，可以同时处理多个客户端的请求，提高了并发性能。
5.数据结构简单：Redis 支持的数据结构非常简单，操作简单，减少了 CPU 的计算负担。
综上所述，Redis 采用了多种优化策略，使得它的读写速度非常快，成为了非常受欢迎的内存数据库之一。

4.Redis + Lua 实现防止订单重复提交，如何实现 ？

可以使用 Redis 的 SETNX 命令来实现防止订单重复提交，它可以保证在同一时间只有一个线程可以执行 SETNX 命令。具体实现步骤如下：
将订单号作为 key 存入 Redis 中，value 为 1。
使用 Lua 脚本来保证操作的原子性，防止并发问题。脚本如下：

local key = KEYS[1]
local value = ARGV[1]
local result = redis.call('SETNX', key, value)
if result == 1 then
    redis.call('EXPIRE', key, 60) -- 设置过期时间，防止长时间占用 Redis 内存
end
return result
1
2
3
4
5
6
7

执行 Lua 脚本，如果返回值为 1，则表示订单号未被占用，可以执行后续操作；如果返回值为 0，则表示订单号已被占用，不能重复提交订单。
需要注意的是，为了防止内存泄漏，需要设置订单号的过期时间，一般可以设置为订单处理时间的两倍。另外，如果需要支持批量提交订单，可以将订单号列表作为参数一次性传入 Lua 脚本中进行处理。

5.Redis + Lua 实现防止订单重复提交，这种方式可能出现什么问题吗 ？

为了防止内存泄漏，需要设置订单号的过期时间，一般可以设置为订单处理时间的两倍。另外，如果需要支持批量提交订单，可以将订单号列表作为参数一次性传入 Lua 脚本中进行处理。

6.给一个可能出现的问题:事务执行时间过长，导致事务没执行完， Redis 中的锁已经过期释放了， 如何解决 ？

可以使用 Redis 的 Lua 脚本来实现分布式锁的自动续期。具体实现方式是在获取锁的时候，使用 Lua 脚本来判断当前的锁是否已经过期，如果没有过期，则正常获取锁，如果已经过期，则在获取锁的同时，使用 Lua 脚本来给锁续期。这样就能够保证在事务执行时间过长，导致锁已经过期的情况下，锁能够自动续期，从而避免出现问题。另外，还可以调整 Redis 的超时时间，根据实际情况来设置超时时间，以避免事务执行时间过长导致锁过期的问题。

7.在这个过程中 Redis 的锁要手动释放嘛 ？还是直接等它过期自动释放 ？ 对应的情况可能出现的问题 ？

当 Redis 中的锁已经过期释放了，一般情况下应该等待它自动释放。手动释放锁可能会导致一些问题，比如在释放锁之前，其他节点已经获得了相同的锁，从而导致数据不一致的问题。
在 Redis 锁过期自动释放的情况下，可能会出现其他节点尝试获取相同锁的情况。这种情况下，需要确保只有一个节点能够获得锁，其他节点需要等待。此外，如果事务执行时间过长，可能会导致其他节点长时间等待，从而影响系统的性能。

8.Redis全局唯一ID是如何实现的，其他的实现方案有那些？

Redis全局唯一ID的实现方案主要有两种：
1.使用Redis的INCR命令。通过在Redis中设置一个计数器，每次调用INCR命令来生成一个新的ID。这种方案简单、高效，但是存在并发问题，需要考虑并发情况下ID的唯一性和连续性。
2.使用Redis的Lua脚本。通过在Redis中执行一段Lua脚本来生成ID，可以保证ID的唯一性和连续性。这种方案相对更复杂，但是可以更好地应对并发情况。
除了Redis，还有其他的实现方案，比如：
1.UUID（通用唯一识别码）。UUID是一种标准化的全局唯一ID生成算法，可以保证ID的唯一性，但是生成的ID比较长，不适合作为数据库主键等场景。
2.Twitter的Snowflake算法。Snowflake算法是一种分布式ID生成算法，可以生成唯一的64位ID，具有高效、高可用等特点，适用于分布式系统场景。

9.这种实现方案在 Redis 主存集群下可能出现什么问题？ 解决方案 ？

10.其他生成 Redis全局唯一ID 的方案了解过吗 ？互相对比着聊一下 ？

11.SQL 如何查看慢查询日志

要查看慢查询日志，您可以按照以下步骤操作：
1.打开 MySQL 的配置文件 my.cnf（或 my.ini）。
2.在 [mysqld] 下添加以下配置：

slow_query_log = 1
slow_query_log_file = /var/log/mysql/mysql-slow.log
long_query_time = 2
1
2
3

其中，slow_query_log = 1 表示开启慢查询日志，slow_query_log_file 指定慢查询日志的文件路径和文件名，long_query_time 指定查询时间超过多少秒才被记录到慢查询日志中。
3.重启 MySQL。
4.使用以下命令查询慢查询日志：

sudo tail -f /var/log/mysql/mysql-slow.log
1

其中，-f 表示实时刷新日志文件，您也可以使用其他文本编辑器打开该文件查看。
注意：慢查询日志会记录所有执行时间超过 long_query_time 的查询语句，这可能会导致日志文件非常大，因此应该定期清除日志文件或将日志文件压缩存档。

12.如何使用 explain 命令分析 SQL 执行日志，主要看那几个字段呢 ？

使用 explain 命令可以分析 SQL 执行计划，主要可以看以下几个字段：
1.id：查询的序列号，每个 SELECT 子句都有一个唯一的 id，从大到小依次执行。
2.select_type：查询的类型，包括 SIMPLE、PRIMARY、UNION、SUBQUERY、DERIVED 等。
3.table：查询的表名或者 derived 表名。
4.partitions：匹配的分区数。
5.type：访问类型，包括 system、const、eq_ref、ref、range、index、ALL 等，从最优到最差依次排序。
6.possible_keys：可能使用的索引。
7.key：实际使用的索引。
8.key_len：索引的长度。
9.ref：哪个字段或常数与 key 一起使用。
10.rows：估计的行数。
11.filtered：返回的行占总行数的比例。
12.Extra：额外的信息，包括 Using index、Using temporary、Using filesort 等。
这些字段可以帮助我们分析 SQL 查询的性能，优化查询的方式和索引的使用。

13. MySQL 主要有什么索引呢？

MySQL 主要有以下几种索引：
1.B-Tree 索引：最常用的索引类型，可用于所有的比较操作，包括 =、<、>、<=、>=、BETWEEN、IN、和部分 LIKE 查询。
2.哈希索引：只能用于精确匹配查找，不支持范围查找和排序，使用场景较为有限。
3.全文索引：主要用于对文本类型的数据进行全文检索，支持 MATCH AGAINST 和 BOOLEAN 模式查询。
4.空间索引：主要用于对空间数据类型的数据进行地理位置查询。
5.全文空间索引：是全文索引和空间索引的结合，主要用于对空间数据类型的数据进行全文检索和地理位置查询。
6.前缀索引：只索引字符串的前缀，可以用于优化查询效率，但会增加索引的大小。

14.了解联合索引吗， 联合索引要注意什么呢

联合索引是指在多个列上创建的索引，它可以提高多个列的查询效率。联合索引需要注意以下几点：
1.索引列的顺序要考虑到查询的频率和过滤的效率，常用的条件放在前面，过滤效果好的条件放在前面，可以提高查询效率。
2.联合索引的长度要适当，过长的联合索引会占用更多的磁盘空间，降低索引的效率。
3.避免创建不必要的联合索引，会影响更新、插入和删除的效率。
4.当查询条件不包括联合索引的第一个列时，联合索引将无法起到作用。
5.当有多个联合索引时，需要根据查询的具体情况选择合适的索引。
总之，创建合适的联合索引可以提高查询效率，但需要根据具体情况进行权衡和优化。

15.如何避免二级索引造成的回表操作呢 ？ 解决方案 ？

为了避免二级索引造成的回表操作，可以采用覆盖索引或者使用联合索引的方式。
覆盖索引是指在查询时，使用的索引包含了需要的所有列数据，不需要再回到主键索引上进行回表操作，从而提高查询效率。
联合索引是指将多个列作为索引的组合，可以在查询时直接使用该索引获得需要的数据，避免了回表操作。
除此之外，还可以通过减少二级索引的使用来避免回表操作，例如使用查询缓存、修改数据表结构等方式。

16.你有考虑过分库分表吗，因为数据量可能很大 ？

在Java项目中，当数据量很大时，分库分表是一种常见的解决方案。
分库分表的基本原理是将一个大的数据库分成多个小的数据库（分库），每个小的数据库又可以分成多个表（分表）。这样可以将数据分散到不同的服务器上，从而减轻单个数据库服务器的压力，提高了系统的性能和可扩展性。
以下是处理大数据量的Java项目中考虑分库分表的一些建议：
1.根据业务需求确定分库分表的策略，例如按照数据类型、地域、时间等来划分。
2.在设计数据库结构时，考虑到数据的冗余和一致性问题，避免数据的重复和不一致。
3.在应用程序中，采用分布式事务来保证分库分表操作的一致性。
4.使用分库分表中间件，例如Sharding-JDBC，来简化分库分表的操作。
5.在进行分库分表之前，进行充分的测试和评估，以确保系统的稳定性和可靠性。
总之，分库分表是处理大数据量Java项目中一种有效的解决方案，但需要充分考虑业务需求和实际情况，以确保系统的稳定性和可靠性。

17.索引的底层具体实现？

索引的底层实现可以有多种方式，其中比较常见的是B树索引和哈希索引。B树索引是一种树形结构，可以支持范围查找和排序等操作，适合处理区间查询。哈希索引则是一种散列表结构，适合处理等值查询，但不支持范围查找和排序。此外，还有一些其他的索引结构，比如全文索引等。不同的数据库管理系统也可能会选择不同的索引实现方式，以满足不同的需求。

18.你可以把 MQ 解决实现超时自动取消说清楚吗 ？

当使用 MQ 实现异步消息通信时，有时候消息可能因为各种原因无法被消费者及时处理，这时候我们希望能够设置一个超时时间，如果消息在超时时间内仍然未被消费者处理，则自动取消该消息。实现这一功能的一种常见方法是使用消息的 TTL（Time-To-Live）属性，即消息的生存时间。我们可以在发送消息时设置消息的 TTL，当消息在队列中等待时间超过 TTL 时，队列会自动将该消息删除并返回一个“消息过期”的提示。通过这种方式，我们就可以实现超时自动取消的功能。当然，具体的实现方式可能因为消息队列的不同而有所差异。

19.你这个项目里，JC垃圾回收机制用的哪一种呢 ？ 怎么配 JVM 启动参数呢，你都配过什么 ？

20.聊网络 ？

21.网络模型？

网络模型通常是指计算机网络的逻辑结构或者通信协议的规范。常见的网络模型有OSI模型和TCP/IP模型。OSI模型将计算机网络分为了七个层次，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。而TCP/IP模型则将计算机网络分为四层，分别是网络接口层、网络层、传输层和应用层。两种模型都是为了规范计算机网络通信过程中的规则和标准，从而使得不同厂商的设备可以互相通信。

22.对http的了解 ？

HTTP（超文本传输协议）是一种用于传输超媒体文档（如 HTML）的应用层协议。它是互联网上应用最为广泛的协议之一，用于在 Web 浏览器和 Web 服务器之间传输数据。HTTP 使用 TCP 作为其传输层协议，通过在客户端和服务器之间建立连接来传输数据。HTTP 是一种无状态协议，即服务器不会保留任何关于客户端的信息，每个请求都是独立的。HTTP 的请求方法包括 GET、POST、PUT、DELETE 等，响应状态码包括 200 OK、404 Not Found、500 Internal Server Error 等。最新版本是 HTTP/2，它能够更有效地传输数据，提高网站性能和速度。

23.对https的了解 ？

HTTPS是Hypertext Transfer Protocol Secure的缩写，是一种更加安全的HTTP协议。它通过在HTTP下添加SSL/TLS加密层来保护数据传输的安全性。使用HTTPS时，客户端和服务器之间的通信会被加密，以防止中间人攻击和窃听。HTTPS在安全性和隐私方面比HTTP更加可靠，因此在需要保护用户数据的网站和应用程序中得到了广泛的应用。

24.自己抓过包吗 ？

25.三次握手 | 四次挥手 | 访问百度过程 ？

三次握手是TCP协议中建立连接的过程，其步骤如下：
1.客户端向服务器发送一个SYN报文，其中序列号随机生成。
2.服务器收到SYN报文后，向客户端发送一个SYN+ACK报文，其中SYN字段表示确认客户端的SYN报文，ACK字段表示确认3.客户端的序列号，同时自己也随机生成一个序列号。
4.客户端收到SYN+ACK报文后，向服务器发送一个ACK报文，其中ACK字段表示确认服务器的SYN+ACK报文，序列号为收到的序列号+1。
四次挥手是TCP协议中关闭连接的过程，其步骤如下：
1.客户端向服务器发送一个FIN报文，表示客户端已经没有数据要发送了。
2.服务器收到FIN报文后，向客户端发送一个ACK报文，表示已经收到了客户端的FIN报文。
3.服务器向客户端发送一个FIN报文，表示服务器已经没有数据要发送了。
4.客户端收到FIN报文后，向服务器发送一个ACK报文，表示已经收到了服务器的FIN报文。
访问百度过程：
1.客户端向DNS服务器查询百度的IP地址。
2.客户端向百度的IP地址发送HTTP请求报文。
3.服务器接收到HTTP请求报文后，返回HTTP响应报文。
4.客户端接收到HTTP响应报文后，渲染页面并显示给用户。

26.常用状态码有什么， 499表示什么 ？

常用的HTTP状态码有以下几种：
1.1xx：信息性状态码，表示服务器已经接收到请求，正在处理中。
2.2xx：成功状态码，表示服务器已经成功地接收到、理解并接受请求。
3.3xx：重定向状态码，表示需要客户端进一步的操作才能完成请求。
4.4xx：客户端错误状态码，表示客户端发送的请求有错误。
5.5xx：服务器错误状态码，表示服务器处理请求时发生了错误。
而 499 状态码是一个非标准的状态码，它表示客户端在等待服务器响应时已经关闭了连接。这个状态码通常只在Nginx服务器中出现，Nginx服务器在处理请求时，如果客户端在等待响应时关闭了连接，Nginx就会返回499状态码。通常情况下，这个状态码并不是一个错误码，而是一个服务器行为的反映。

27.Linux常用命令了解有那些呢， 自己配磁盘应该怎么配呢 ？

常用Linux命令有很多，以下是一些比较基础的：
1.ls：列出目录内容
2.cd：切换目录
3.mkdir：创建目录
4.rm：删除文件或目录
5.cp：复制文件或目录
6.mv：移动文件或目录
7.touch：创建空文件
8.cat：查看文件内容
9.chmod：修改文件或目录的权限
10.ps：查看进程信息
11.top：实时查看系统性能
关于磁盘的配制，需要先了解一下硬盘的分区和格式化，然后才能进行磁盘的配制。一般来说，可以通过以下步骤进行磁盘的配制：
1.插入硬盘并启动电脑，进入系统。
2.打开磁盘管理工具，查看硬盘是否被识别。
3.对硬盘进行分区和格式化，可以选择NTFS或者FAT32格式。
4.创建一个新的分区，指定分区大小和名称。
5.格式化新分区，选择文件系统类型和分配单位大小。
6.挂载新分区，指定挂载点和挂载选项。
7.检查新分区是否成功挂载，可以通过命令df -h进行查看。
需要注意的是，在进行磁盘配制的过程中，一定要小心操作，避免误操作导致数据丢失。建议在进行磁盘配制之前，先备份重要数据。

28.Linux查看端口号的命令是什么呢

Linux查看端口号的命令是netstat。可以使用命令 netstat -tunlp 来查看当前系统中所有的端口号以及相应的进程。其中，-t 表示 TCP 协议，-u 表示 UDP 协议，-n 表示以数字形式显示端口号和 IP 地址，-l 表示只显示监听状态的端口，-p 表示显示进程名称和进程 ID

29.操作系统，关于操作系统你了解多少呢 ？

操作系统是计算机系统中的核心软件，它主要负责管理计算机硬件资源，提供给用户和应用程序一个统一的界面和服务接口。常见的操作系统包括Windows、Linux、Mac OS等。操作系统的功能包括进程管理、内存管理、文件系统管理、设备管理等。它们的实现方式和特点也各不相同。

30.线程池的工作机制

线程池是一种用于管理和调度线程的技术，它可以在应用程序启动时创建一定数量的线程，并将它们放置在一个线程池中，等待被调度。线程池可以避免不必要的线程创建和销毁开销，提高线程的复用率和系统的性能。
线程池的工作机制如下：
1.当应用程序需要执行一个任务时，它将该任务提交给线程池。
2.线程池检查是否有空闲线程可用，如果有，则将任务分配给一个空闲线程执行。
3.如果没有空闲线程可用，线程池会根据预设的规则创建新的线程，并将任务分配给其中一个执行。
4.执行完任务后，线程将返回到线程池中，等待下一个任务的分配。
5.线程池还可以设置最大线程数和任务队列，当任务数量超过最大线程数时，将任务放入任务队列中，等待线程池中有空闲线程时再执行。
6.线程池还可以设置超时时间，当线程执行任务时间超过预设的时间时，线程池将强制结束该线程，以避免长时间占用系统资源。
总之，线程池通过管理和复用线程，提高了系统的性能和资源利用率。

31.线程池工作细节？

线程池是一种常用的多线程编程技术，它可以优化多线程的性能和资源利用率，同时也可以避免线程过多导致的系统性能下降和内存占用过大等问题。
线程池的工作细节通常包括以下几个方面：
1.线程池的创建和初始化：线程池的创建和初始化通常包括设置线程池的大小、最大线程数、任务队列等参数，以及创建线程池的管理器和工作线程等。
2.任务提交和处理：任务提交和处理是线程池的核心功能，它通常包括将任务添加到任务队列中，然后由工作线程从队列中取出任务并执行任务。
3.线程的管理和调度：线程池需要对线程进行管理和调度，包括对线程的创建、销毁、休眠和唤醒等操作。
4.异常处理和错误处理：线程池需要能够处理任务执行过程中可能出现的异常和错误，以确保线程池的稳定性和可靠性。
5.性能监控和统计：线程池需要能够对线程池的性能进行监控和统计，以便及时发现和解决可能存在的性能问题。
总之，线程池是一个复杂的多线程编程技术，需要考虑多方面的因素，才能实现高效、稳定和可靠的多线程编程。

32.为什么是这样的流程 ，为什么需要这个队列？

因为线程池中的线程数量是有限的，如果任务提交的速度过快，超过了线程池中的线程数量，那么就需要一个任务队列来缓存任务，等待空闲线程来执行。同时，任务队列还能够避免任务提交和任务执行之间的竞争和互斥，提高了线程池的效率和稳定性。

33.线程池里面的线程是怎么销毁的

线程池中的线程可以通过两种方式进行销毁：
1.主动销毁：线程池中的线程在执行任务后，可以主动调用线程池的销毁方法，通知线程池将自己销毁。
2.被动销毁：线程池中的线程在执行任务时，可以通过异常或错误等方式退出，线程池会检测到线程的异常退出，并将其从线程池中移除。
无论是哪种方式，线程池中的线程在销毁前都需要完成当前任务的执行，并释放占用的资源，如线程所持有的锁、IO资源等。同时，线程池在销毁线程时，也需要注意线程间的协作和同步，避免出现死锁等问题。

34.操作系统内存分配机制

操作系统内存分配机制是指操作系统通过管理内存的方式为应用程序分配内存。常见的内存分配机制有两种：静态分配和动态分配。
静态分配是指在编译或链接时，将内存空间分配给应用程序。这种分配方式具有确定性和高效性，但是会浪费一定的内存空间。
动态分配是指在应用程序运行时，根据需要动态地为其分配内存。这种分配方式具有灵活性，但是会增加系统的开销和复杂性。
常见的动态内存分配方式有三种：连续分配、离散分配和虚拟存储器。
连续分配是指将内存空间划分为若干个等大小的块，然后分配给应用程序。这种方式简单高效，但是容易产生内存碎片，影响内存利用率和性能。
离散分配是指将内存划分为不等大小的块，根据应用程序的需要进行分配。这种方式可以减少内存碎片，但是会增加内存管理的复杂度。
虚拟存储器是指将物理内存和磁盘空间结合起来，形成一个统一的地址空间。这种方式可以扩大内存空间，提高内存利用率，但是会增加系统的开销和复杂度。
操作系统选择哪种内存分配方式，取决于系统的需求和设计目标。

36.进程和线程核心区别

进程和线程是操作系统中的两个重要概念，它们都是操作系统中的执行单元，但是它们之间存在一些核心区别。
1.资源占用：进程是系统分配资源的基本单位，每个进程都有自己的地址空间、文件句柄等系统资源，进程之间的资源是相互独立的；而线程是在进程内的一条执行路径，线程共享进程的资源，因此多个线程共享同一进程的资源。
2.调度：进程是操作系统进行资源分配和调度的基本单位，进程调度的时候会考虑到各种资源的利用率；而线程是操作系统进行调度的基本单位，由于线程共享进程的资源，因此线程调度的开销比进程调度要小。
3.创建和撤销：进程的创建和撤销需要进行系统调用，开销比较大；而线程的创建和撤销只需要在进程的内部进行即可，开销比较小。
4.通信：进程之间通信的方式有很多种，例如管道、消息队列、共享内存等；而线程之间共享进程的资源，因此线程之间的通信方式可以简单直接，例如使用全局变量等方式。
综上所述，进程和线程之间的核心区别主要在于资源占用、调度、创建和撤销、通信等方面。在实际应用中，需要根据具体的场景选择进程或线程来完成任务。