12月25日GM金融面试汇总

分布式架构：

• Sentinel
• 分布式事务

MySQL:

• Mysql的存储引擎，以及区别?
• Mysql的索引分类，索引实现原理？

MQ

• MQ的集群架构？
• MQ 的消费端消费消息的过程？
• MQ是如何确定哪个消费者消费哪些queue ？
• 消费失败的信息在mq的位置发生变化吗？
• MQ消息消费失败的消息是如何进入私信队列的？

基础

• 线程池的创建过程和核心参数？
• 创建核心线程数是什么时候创建的？是创建线程池的时候就创建的？还是使用的时候才创建？
• 线程池中多余的线程如何销毁？（队列满了之后新增到了最大线程数）
• 线程池在什么业务中使用？
• ThreadLocal工作原理，数据如何在两个线程中传递？

Dubbo

• Dubbo的服务发布过程服务 ，服务消费过程？
• Dubbo的SPI和JDK的SPI区别？
• Dubbo的元数据信息存储位置？

算法

• LRU算法
• 链表反转

---

MySQL

Mysql的存储引擎，以及区别?

存储引擎是存储数据、建立索引、更新/查询数据等技术的实现方式。

存储引擎是基于表的，而不是 基于库的，所以存储引擎也可被称为表类型。

比较重要的三种存储引擎: InnoDB 、MyIASM 、Memory

其中 InnoDB 是Mysql 默认的存储引擎，支持事务、行级锁、外键等高级功能。

MyIASM 不支持事务、不支持行级锁，只有表锁，适用于读写比较低的应用；

Memory 把数据存储在内存中，读写速度极快，但是容易出现数据丢失，另外要求存储的数据长度不变的格式，则Blob和text类型不可用。

算法

• LRU算法

package org.example.牛客.面试榜单NC;

import java.util.HashMap;
import java.util.Map;

/**
 * NC93 设计LRU缓存结构
 * https://www.nowcoder.com/practice/5dfded165916435d9defb053c63f1e84?tpId=117&rp=1&ru=%2Fexam%2Foj&qru=%2Fexam%2Foj&sourceUrl=%2Fexam%2Foj%3Fpage%3D1%26tab%3D%25E7%25AE%2597%25E6%25B3%2595%25E7%25AF%2587%26topicId%3D117&difficulty=&judgeStatus=&tags=&title=&gioEnter=menu
 */
public class LRUCache {

    int capacity ;

    int size ;

    Map<Integer,ListNode> cache ;

    ListNode head ;

    ListNode tail ;

    public LRUCache(int capacity) {
        this.capacity = capacity ;
        this.size = 0 ;
        cache = new HashMap<>();
        head = new ListNode();
        tail = new ListNode();
        head.next = tail ;
        tail.pre = head ;
    }

    public int get(int key){
        ListNode node = cache.get(key);
        if(node!= null){
            removeToHead(node);
            return node.value;
        }
        return -1 ;
    }

    private void removeToHead(ListNode node) {
        // 删除节点
        removeNode(node);
        // 头结点新增节点
        addToHead(node);
    }

    private void removeNode(ListNode node) {
        // head >> 1 >> 2 >> 3
        ListNode pre = node.pre;
        pre.next = node.next ;
        node.next.pre = pre ;
    }

    private void addToHead(ListNode node) {
        // head >> 2 >> 3  head >> 1 >> 2 >> 3
        ListNode next = head.next;
        head.next = node ;
        node.pre = head ;
        node.next = next ;
        next.pre = node ;
    }
    private ListNode removeLastNode() {
        // head >> 2 >> 3 >> tail
        ListNode delNode = tail.pre;
        removeNode(delNode);
        return delNode ;
    }

    public void set(int key ,int value){
        ListNode node = cache.get(key);
        if(node == null){
            ListNode newHead = new ListNode(key,value);
            cache.put(key,newHead);
            size++ ;
            addToHead(newHead);
            if(size> capacity){
                //移除最后的元素
                ListNode dNode = removeLastNode();
                cache.remove(dNode.key);
                size-- ;
            }
        }else {
            node.value = value ;
            cache.put(key,node);
            removeToHead(node);
        }
    }



    class ListNode{
        int key ;
        int value ;

        ListNode next ;

        ListNode pre ;

        public ListNode() {
        }

        public ListNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
}

• 链表反转

•   public ListNode ReverseList (ListNode head) {
          // 使用栈来解决
          if(head == null || head.next==null){
              return head ;
          }
          Stack<ListNode> st = new Stack<>();
          while (head!=null){
              st.add(head);
              head = head.next;
          }
          ListNode res = st.pop();
          ListNode cur = res ;
          while(!st.isEmpty()){
              cur.next = st.pop();
              cur = cur.next;
          }
          cur.next = null ;
          return res ;
      }
  
      class ListNode {
          int val;
          ListNode next = null;
          public ListNode(int val) {
              this.val = val;
          }
      }