¡Preguntas comunes sobre la entrevista de Java! ¡Una visita obligada al prepararse para la entrevista de reclutamiento de primavera!

Tabla de contenido

• Preguntas de entrevista
• Habilidades de entrevista

Preguntas de entrevista

Conceptos básicos de Java

• Cuénteme sobre su comprensión de Fail-Fast
• Que es orientado a objetos
• ¿Cuál es la diferencia entre JDK y JRE?
• ¿Cuál es la diferencia entre == y es igual a
• Si el hashCode () de dos objetos es el mismo, equals () también debe ser verdadero, ¿verdad?
• ¿Cuál es el papel de final en Java?
• ¿Es String un tipo de datos básico?
• ¿Cuáles son las clases para manipular cadenas en Java? ¿Cuál es la diferencia entre ellos?
• ¿Es String str = "i" lo mismo que String str = new String ("i")?
• ¿Cómo invertir la cuerda?
• ¿Cuáles son las diferencias entre clases ordinarias, clases abstractas e interfaces?
• ¿Pueden las clases abstractas utilizar la modificación final?
• La diferencia entre sobrecargar y reescribir

15. ¿Cuántos tipos de flujos de E / S hay en Java?
16. ¿Cuál es la diferencia entre BIO, NIO y AIO?
17. ¿Cuáles son los métodos habituales de archivos?

Multihilo

18. ¿Cuál es la diferencia entre paralelo y concurrencia?
19. ¿La diferencia entre hilo y proceso?
20. ¿Qué es un hilo de demonio?
21. ¿Cuáles son las formas de crear hilos?
22. ¿Cuál es la diferencia entre ejecutable y invocable?
23. ¿Cuáles son los estados de los hilos?
24. ¿Cuál es la diferencia entre dormir () y esperar ()?
25. ¿Cuál es la diferencia entre notificar () y notificar a todos ()?
26. ¿Cuáles son las formas de crear un grupo de subprocesos?
27. ¿Cuál es la diferencia entre thread run () y start ()?
28. ¿Cuáles son los estados del grupo de subprocesos?
29. ¿Cuál es la diferencia entre los métodos submit () y execute () en el grupo de subprocesos?
30. ¿Cómo garantizar el funcionamiento seguro de varios subprocesos en un programa Java?
31. ¿Cuál es el principio de actualización de los bloqueos de subprocesos múltiples?
32. ¿Qué es un punto muerto?
33. ¿Cómo prevenir el estancamiento?
34. ¿Qué es ThreadLocal? ¿Cuáles son los escenarios de uso?
35. Hable sobre el principio de implementación subyacente de sincronizado?
36. ¿Cuál es la diferencia entre sincronizado y volátil?
37. ¿Cuál es la diferencia entre sincronizado y bloqueo?
38. ¿Cuál es la diferencia entre sincronizado y ReentrantLock?
39. ¿Cuéntame sobre el principio atómico?

resorte / resorte MVC

• SpringMVC habla sobre la diferencia entre filtros, oyentes e interceptores
• [SpringBoot 系列] (https: // github. Com / zhonghuasheng / Tutorial / issues? Q = label% 3ASpringBoot +)
  • [El principio de inicio de SpringBoot] (https: // github. Com / zhonghuasheng / Tutorial / issues / 185)

40. ¿Por qué usar primavera?
41. Explique qué es aop.
42. Explique ¿qué es ioc?
43. ¿Cuáles son los principales módulos de primavera?
44. ¿Cuáles son los métodos de inyección habituales para primavera?
45. ¿Los frijoles en primavera son seguros para el hilo?
46. ¿Qué tipo de alcance admite Spring para los frijoles?
47. ¿Cuáles son las formas de ensamblar frijoles automáticamente en primavera?
48. ¿Cuáles son los métodos de implementación de transacciones de primavera?
49. ¿Hablar sobre el aislamiento de transacciones de Spring?
50. ¿Hablar sobre el proceso de ejecución de Spring MVC?
51. ¿Cuáles son los componentes de Spring MVC?
52. ¿Cuál es el propósito de @RequestMapping?
53. ¿Cuál es el papel de @Autowired?
    Cuatro, primavera / primavera nube
54. ¿Qué es la bota de primavera?
55. ¿Por qué usar la bota de primavera?
56. ¿Qué es el archivo de configuración principal de Spring Boot?
57. ¿Qué tipos de archivos de configuración de Spring Boot existen? ¿Cuál es la diferencia entre ellos?
58. ¿Cuáles son las formas de lograr la implementación en caliente con Spring Boot?
59. ¿Cuál es la diferencia entre jpa e hibernate?
60. ¿Qué es la nube de primavera?
61. ¿Cuál es la función del disyuntor de nube de resorte?
62. ¿Cuáles son los componentes centrales de la nube de primavera?
    Cinco, Mybatis
63. ¿Cuál es la diferencia entre # {} y $ {} en mybatis?
64. ¿Cuántos métodos de paginación tiene mybatis?
65. ¿RowBounds consulta todos los resultados a la vez? ¿Por qué?
66. ¿Cuál es la diferencia entre la paginación lógica mybatis y la paginación física?
67. ¿Mybatis admite la carga diferida? ¿Cuál es el principio de carga diferida?
68. ¿Cuéntame sobre la caché de primer nivel y la caché de segundo nivel de mybatis?
69. ¿Cuáles son las diferencias entre mybatis e hibernate?
70. ¿Qué ejecutores tiene mybatis?
71. ¿Cuál es el principio de realización del complemento de paginación mybatis?
72. ¿Cómo escribir un complemento personalizado para mybatis?
    Seis, kafk, guardián del zoológico
73. ¿Se puede usar Kafka por separado del guardián del zoológico? ¿Por qué?
74. ¿Cuántas estrategias de retención de datos tiene Kafka?
75. Kafka ha configurado 7 días y 10G para borrar los datos al mismo tiempo. Para el quinto día, el mensaje llegó a 10G. ¿Qué hará Kafka en este momento?
76. ¿Qué puede hacer que Kafka funcione más lento?
77. ¿A qué debo prestar atención al utilizar el clúster de Kafka?
78. ¿Qué es el guardián del zoológico?
79. ¿Cuáles son las funciones del cuidador del zoológico?
80. ¿Cuántos modos de implementación tiene el guardián del zoológico?
81. ¿Cómo asegura zookeeper la sincronización de los nodos maestro y esclavo?
82. ¿Por qué hay un nodo maestro en el clúster?
83. Hay 3 servidores en el clúster y uno de los nodos está inactivo. ¿Se puede seguir usando Zookeeper en este momento?
84. ¿Cuéntame sobre el mecanismo de notificación del cuidador del zoológico?
    Siete, Redis
85. ¿Qué es Redis? ¿Cuáles son los escenarios de uso?
86. ¿Cuáles son las funciones de redis?
87. ¿Cuál es la diferencia entre redis y memecache?
88. ¿Por qué redis es de un solo subproceso?
89. ¿En qué circunstancias se ralentizará la redis?
90. ¿Qué es la penetración de caché? ¿Como lidiar con?
91. ¿Qué tipos de datos admite redis?
92. ¿Cuáles son los clientes Java compatibles con redis?
93. ¿Cuál es la diferencia entre Jedis y redisson?
94. ¿Cómo garantizar la coherencia de los datos de la caché y la base de datos?
95. ¿De cuántas formas es la persistencia de redis?
96. ¿Cómo implementa redis los bloqueos distribuidos?
97. ¿Cuáles son las desventajas de los bloqueos distribuidos de redis?
98. ¿Cómo optimiza redis la memoria?
99. ¿Cuáles son las estrategias de eliminación de redis?
100. ¿Cuáles son los problemas de rendimiento comunes de redis? ¿Cómo resolverlo?
     Ocho, JVM
101. Háblame de los componentes principales de Jvm. ¿Y su papel?
102. ¿Hablar sobre el área de datos en tiempo de ejecución de Jvm?
103. ¿Cuéntame la diferencia entre pilas?
104. ¿Qué son las colas y las pilas? ¿Cual es la diferencia?
105. ¿Qué es el modelo de delegación principal?
106. ¿Hablar del proceso de ejecución de la carga de clases?
107. ¿Cómo juzgar si el objeto se puede reciclar?
108. ¿Cuáles son los tipos de referencia en Java?
109. ¿Cuéntame qué algoritmos de recolección de basura tiene jvm?
110. ¿Cuéntame qué recolectores de basura tiene jvm?
111. ¿Cuéntame más sobre el recolector de basura CMS?
112. ¿Qué son los recolectores de basura de nueva generación y los recolectores de basura de vieja generación? ¿Cual es la diferencia?
113. ¿Describe brevemente cómo funciona el recolector de basura generacional?
114. ¿Hablar de las herramientas de ajuste de jvm?
115. ¿Cuáles son los parámetros de ajuste de jvm de uso común?

Cuando el hilo de Java ejecuta el método nativo, el contador del programa está vacío. Cómo asegurarse de que la ubicación de la ejecución del programa después de la ejecución nativa
está escrita por código que no es Java, como C, C ++, no pueden generar código de bytes durante la compilación de Java , es decir, la JVM no puede obtenerlo. En la implementación nativa, los métodos nativos solo se pueden llamar a través de instrucciones del sistema, por lo que el valor del contador del programa está vacío y no está definido cuando se ejecuta nativo. El método nativo es ejecutado directamente por la plataforma nativa, luego de que el método nativo es ejecutado, saldrá (stack frame pop), y el método sale y regresa al lugar donde fue llamado para continuar ejecutando el programa.

• Presentar la teoría del límite
• Anotaciones comunes para Java, Spring, SpringBoot, SpringCloud
• Esta vez, comprenda a fondo qué son BIO, NIO y multiplexación

ordenador

• ¿Por qué la caché de la CPU sigue siendo tan pequeña?

base de datos

• ¿Cómo cambiar la longitud de los campos de la tabla para decenas de millones de datos?
• ¿Qué es la E / S de red?

可以理解为socket和fd(file descriptor文件描述符)

10中网络ID
单线程同步 -> NTP
多线程同步 -> Natty
单线程异步 -> Redis
半同步半异步 -> Natty
多进程同步 -> fastcgi
多线程异步 -> memcached
多进程异步 -> nginx
每请求每进程（现场）-> Apache/CGI
微进程框架 -> erlang/go/lua
协议框架 -> libco/ntyco/libgo

单线程 epoll -> redis
多线程 epoll -> memcached
多进程 epoll -> nginx

epoll底层数据结构是红黑树，还有一个就绪队列。
while(1) {
    epoll_wait(epfd, events, 1024, -1)
}
epoll中的三个函数
epoll_create() 创建一个网络IO
epoll_ctl() 控制connection的
epoll_wait() 多长时间去轮询一次，看有没有数据
服务器端有个事件循环一直在监听有没有数据（缺点是一直占一个cpu）

• Explicar síncrono / asíncrono, bloqueo / no bloqueo

妈妈让我去厨房烧一锅水，准备下饺子
阻塞：水只要没烧开，我就干瞪眼看着这个锅，沧海桑田，日新月异，我自岿然不动，厨房就是我的家，烧水是我的宿命。
非阻塞：我先去我屋子里打把王者，但是每过一分钟，我都要去厨房瞅一眼，生怕时间长了，水烧干了就坏了，这样导致我游戏也心思打，果不然，又掉段了。
同步：不管是每分钟过来看一眼锅，还是寸步不离的一直看着锅，只要我不去看，我就不知道水烧好没有，浪费时间啊，一寸光阴一寸金，这锅必须发我13薪
异步：我在淘宝买了一个电水壶，只要水开了，它就发出响声，嗨呀，可以安心打王者喽，打完可以吃饺子喽~
总结：
阻塞/非阻塞：我在等你干活的时候我在干啥？
阻塞：啥也不干，死等
非阻塞：可以干别的，但也要时不时问问你的进度
同步/异步：你干完了，怎么让我知道呢？
同步：我只要不问，你就不告诉我
异步：你干完了，直接喊我过来就行

在讨论之前先说明一下IO发生时涉及到的对象和步骤，对于一个network IO，它会涉及到两个系统对象：
* application 调用这个IO的进程
* kernel 系统内核

那他们经历的两个交互过程是：
 阶段1 wait for data 等待数据准备
 阶段2 copy data from kernel to user 将数据从内核拷贝到用户进程中

Sistema de picos

1. ¿Cómo controlar la sincronización del botón de compra en la página del producto spike? [Problema de compras]
2. ¿Cómo prevenir la sobreventa?
3. ¿Cómo evitar pedidos repetidos?
4. Cola para realizar un pedido, similar a la operación de 12306 al ingresar a la cola.
   Respuesta de referencia: https://github.com/zhonghuasheng/JAVA/tree/master/seckill#

Habilidades de entrevista

1. Antes de la entrevista, por cortesía y el entrevistador para confirmar si se puede entender el habla, problemas de dialecto
2. Trate de mantener su auto-presentación dentro de los 35 segundos (introducción de información básica, introducción a la experiencia laboral, introducción al motivo de la búsqueda de empleo)
3. Cuando respondo a la pregunta, utilizo lo que entiendo. No responda esta pregunta de manera absoluta. No hay tecnología correcta o incorrecta. Todos tienen una comprensión diferente de la tecnología.
4. Si encuentra un punto de conocimiento que no ha tocado durante la entrevista, puede decir esto: Nos hemos puesto en contacto con este punto de conocimiento, intentaré responder mi comprensión.

Cesto

2. ¿Qué colecciones usas con más frecuencia?

答：集合的话像Collection下的ArrayList, LinkedList; Set下的HashSet; Map下的HashMap，如果涉及到多线程，线程安全的话，会使用ConcurrentHashMap。
问：我们先聊一下ArrayList和LinkedList吧，它们两个在什么场景下会使用它？
答：ArrayList的底层数据结构是数组，不指定ArrayList大小的时候初始化的大小是0，第一次add的时候size会变成10，扩容的话会是之前的1.5倍。ArrayList由于底层是数组，因此随机查找的速度很快，插入和删除效率比较低。因为它底层是数组，因此分配内存空间的时候要求是连续的内存单元，所以如果需要存储的数据量很大的情况下，不建议使用ArrayList。LinkedList的底层是一个带有头节点和尾节点的双向链表，提供了头插（LinkedFirst）和尾插（LinkedLast），插入和删除比较快，不支持随机查询，LinkedList数据的存储不要求内存空间是连续的。
问：如果在多线程的情况下，我既想用List，又想保证线程安全，那怎么办？
答：我知道的有三种方式：1. 使用Vector，它是一个线程安全的List集合，所有的方法都加了synchronized关键字来保证同步，但它性能很差。[读写都加锁，底层也是数组，扩容时是之前的2倍] 2. 使用Collections.SynchronizedList，它是Collections下的一个静态内部类，它把List下的所有方法都变成了线程安全的，于Vector不同的是，它把synchronized加到了方法内部的代码块上，提高了扩展性[锁的粒度变小] 3. 使用CopyOnWriteArrayList，add的时候加锁，读的时候不加锁，提高了读取性能 [锁粒度变小，同时锁范围变小]

3. Hablemos de HashMap con regularidad

答：HashMap在1.7的时候底层使用数组+单链表的数据结构，使用的是头插；1.8使用数组+单链表/红黑树，使用的是尾插。单链表和红黑树之间的转换，当单链表的长度大于等于8，并且它的hash桶大于等于64的时候，它会将单链表转换成红黑树形式存储；它在红黑树的节点的数量小于等于6的时候，它会重新再转换成一个单链表，这是它底层结构的一个变化；当我们往hashmap中put元素的时候，先根据key的hash值得到这个元素在数组中的位置（即下标），然后就可以把这个元素放到对应的位置中了。如果这个元素所在的位子上已经存放有其他元素了，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。从hashmap中get元素时，首先计算key的hashcode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。从这里我们可以想象得到，如果每个位置上的链表只有一个元素，那么hashmap的get效率将是最高的；另外一点是关于它Hash桶的数量，默认是16个，默认的阀值是0.75，这关系到它的扩容。
问：它扩容是怎么扩容的？
答：扩容的时候首先检测数组中的元素个数，负载因子默认是loadFactor=0.75，因此当它哈希桶占用的容量大于12的时候，就会触发扩容，哈希桶会扩容成之前的两倍，把之前的元素再进行一次哈希运算，然后添加到新的哈希桶，然后按照链表或者红黑树重新排列起来。
问：你给我说下它是不是线程安全的？
答：它不是线程安全的，因为在插入操作的时候多线程会有数据覆盖的可能；另外它在1.7的时候，它在put的时候可能会有一个resize的过程，这个过程可能会照成它的头插会形成一个环形链表形成一个死循环，1.8之后改成尾插了。
问：你平时开发的时候怎么去保证它的线程安全？
答：我平时开发的时候会使用ConcurrentHashMap来保证它的线程安全。另外有HashTable也能保证线程安全，但是HashTable锁的是方法。`待续`
问：聊一聊ConcurrentHashMap
答：1.7的时候底层是一个分片数组，使用了segment锁（继承自ReentrantLock），通过每次只给一个段加锁来保证它的线程安全和并发度；另外，在1.8的时候，它改成了和HashMap一样的数据结构，使用数据加单链表或者红黑树的数据结构，在1.8的时候渐渐放弃了这种分片锁机制，而使用的是synchronized加CAS来做的，我们知道在1.6版本的时候JVM对synchronized的优化是非常大的，现在也是用这个方法来保证线程安全。
问：CAS是什么？
答：Compare And Sweep，比较并替换，是乐观锁的一种实现，在修改之前要将之前读到的值与当前内存中的值进行比较，如果一致就写入。CAS可以认为是一种轻量级的锁，在低并发的时候时候效率很快，在高并发的情况下，CAS需要涉及到CPU的计算，容易引起CPU性能的消耗，高并发的情况下还是建议使用状态机或者锁之类的。另外一点就是会产生ABA的问题，因为在读取和写入之间，可能有其他线程率先完成修改，然后又将值改回到之前，这样就误以为当前的值和读取的值是一致的，这个问题可以通过加一个戳或标志位来标识，也就是相当于加个版本号。

4. Mencionaste sincronizado hace un momento, entonces háblame al respecto.

答：关于synchronized，可以用在同步代码块（可指定任意锁）/方法（指定this）/静态方法（指定class对象）。在1.6升级还是蛮大的，首先提供了无锁状态，然后是偏向锁，然后是轻量级锁，然后是重量级锁。偏向锁的话，见名知意，它偏向于获得第一个锁的线程，它会将id写到锁对象的对象头中，等其他线程来的时候，立即会升级到轻量级锁的状态（如果是同一个线程再次进入，先判断是否获取过锁，如果获取过标记位+1，否则修改为1），轻量级锁主要是在低并发的情况下来消除锁的方式，它主要是在你的虚拟机栈中开辟一个空间，叫做Lock Record，将锁对象的Mark Work写到Lock Record，再尝试Lock Record的指针使用CAS去修改锁对象头的那个区域来完成一个加锁的过程，如果再有线程进入的话，并尝试修改这个指针，轻量级锁会升级为一个自旋锁，如果10次未成功就会膨胀成一个重量级锁，也就是一个互斥锁的过程。重量级锁，使用synchronized的时候会在你的代码块前后加上两个指令，monitorenter和monitorexist，通过一个monitor监视器通过计数器的方式来监视这个锁的状态。如果是同步方法的时候，使用的是一个ACC_SYNCHRONIZED标志位，相当于flag，它自动走的是一个同步方法调用的策略，这个原理是比较简单的。
问：什么时候用它？什么时候用ReentrantLock，这个你有考虑吗？
答：有，它两对比的话区别还是蛮大的。从JVM层面来说，synchronized是JVM的一个关键字，ReetrantLock其实是一个类，你需要手动去编码，synchronized使用其实是比较简单的，不需要关心锁的释放；但是使用ReetrantLock的时候你需要手动去lock，然后配合tray finally然后去确保锁的释放，然后ReentrantLock相比synchronized有几个高级特性，当一个线程长期等待得不到锁的时候，你可以手动的去调用一个lockInterruptibly方法尝试中断掉不去等待；另外，它提供了一个公平锁的方式；此外，它提供了一个condition，你可以指定去唤醒绑定到condition身上的线程，来实现一个选择性通知的方式。如果不需要ReentrantLock需要的高级特性的话，建议还是使用synchronized的关键字。
例：因为锁不可逆，如果在早高峰的时候，滴滴打车上的所有锁都升级为重量级锁，那么等过了这个高峰，锁依然是重量级锁，会影响系统的QPS的，所以在使用的时候还是要更具具体的场景来使用

5. ¿Has visto volátiles?

答：volatile修饰的变量保证了多线程下的可见性，当CPU写数据时，发现此变量被volatile修饰时，发现其他CPU中也存在该变量的副本，会发出信号通知其他CPU该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中的变量行是无效的，就重新去内存读取。它是通过计算机的总线嗅探机制（MESI）来实现的，当然它也会照成一个问题，就是volitale会一直嗅探，导致一些无效的交互，引发总线风暴。