博客记录-day125-面试+JVM，MySQL面试题一、第一次面试 1. synchronized关键字原理及普通方法

一、第一次面试

1. synchronized关键字原理及普通方法与静态方法加锁的区别

synchronized基于JVM的监视器锁（Monitor）实现，通过对象头的Mark Word标记锁状态。普通方法加锁（如synchronized method()）锁定的是当前实例对象（this），同一实例的并发调用会被阻塞；静态方法加锁（如synchronized static method()）则锁定类的Class对象（如ClassName.class），所有实例共享同一把类锁。两者的锁粒度不同，普通方法锁实例，静态方法锁类，因此静态锁的并发控制范围更广。

2. 常见垃圾回收算法及适用区域

• 标记-清除：标记无用对象后直接回收，产生内存碎片，适用于老年代（存活对象多）。
• 复制算法：将内存分为两块，仅使用一块存活对象复制到另一块后清空原区，适用于新生代（短命对象多）。
• 标记-整理：标记后整理存活对象至一端，避免碎片，适用于老年代。
• 分代收集：结合上述算法，新生代用复制，老年代用标记-清除/整理，是主流JVM的策略。

3. MySQL索引数据结构

InnoDB默认使用B+树作为索引结构。B+树的特点包括多叉树结构减少磁盘I/O、叶子节点形成有序链表支持高效范围查询、非叶子节点仅存索引键不存数据以节省空间。此外，内存中的哈希索引（如Memory引擎）支持O(1)查询，但不支持范围扫描，故InnoDB以B+树为主。

4. 线程池核心参数

• corePoolSize：核心线程数，即使空闲也保留。
• maximumPoolSize：最大线程数，任务队列满后创建新线程的上限。
• keepAliveTime：非核心线程的空闲存活时间。
• workQueue：任务队列，存放待执行任务（如LinkedBlockingQueue/SynchronousQueue）。
• threadFactory：线程创建工厂，可定制线程名称等。
• handler：拒绝策略（Abort直接报错、Discard丢弃、CallerRuns由调用线程执行、DiscardOldest丢弃旧任务）。

5. DDD（领域驱动设计）

DDD是一种以业务领域为核心的设计方法，通过领域模型（实体、值对象、聚合根等）映射复杂业务逻辑，解决传统开发中领域与技术代码混杂的问题。其核心是划分限界上下文，明确领域边界，通过战术设计（如领域事件、仓储）和战略设计（分层架构）构建高内聚系统。DDD强调与领域专家协作，避免“贫血模型”，提升代码可维护性与业务表达力。

6. 查找最长回文字符串

class Main {
    public static void main(String[] args) {
        String input = "babad";
        System.out.println("输入：" + input);
        System.out.println("输出：" + longestPalindrome(input));
        
        // 其他测试用例
        System.out.println("输入：cbbd → 输出：bb");
        System.out.println("输入：a → 输出：a");
        System.out.println("输入：ac → 输出：");
    }

    public static String longestPalindrome(String s) {
        if (s == null || s.length() < 1) return "";
        
        int start = 0, end = 0;
        for (int i = 0; i < s.length(); i++) {
            int len1 = expandAroundCenter(s, i, i);     // 奇数长度
            int len2 = expandAroundCenter(s, i, i + 1); // 偶数长度
            int maxLen = Math.max(len1, len2);
            
            if (maxLen > end - start) {
                start = i - (maxLen - 1)/2;
                end = i + maxLen/2;
            }
        }
        return s.substring(start, end + 1);
    }

    private static int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() 
                && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1; // 返回长度
    }
}

7、反转链表

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { 
        val = x; 
    }
}

class Main {
    public static void main(String[] args) {
    
        String input = "1->2->3->4->5->NULL";
        System.out.println("输入链表：" + input);
        
        ListNode head = createLinkedList(input);
        ListNode reversed = reverseList(head);
        System.out.print("反转链表：");
        printLinkedList(reversed);
    }

     //处理输入
    // 字符串转链表
    public static ListNode createLinkedList(String input) {
        String[] nodes = input.split("->");
        ListNode dummy = new ListNode(-1);
        ListNode current = dummy;
        
        for (String node : nodes) {
            if (node.equals("NULL")) break;
            current.next = new ListNode(Integer.parseInt(node));
            current = current.next;
        }
        return dummy.next;
    }

    // 反转链表（迭代法）
    public static ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
    
    //处理输出
    // 打印链表
    public static void printLinkedList(ListNode head) {
        StringBuilder sb = new StringBuilder();
        while (head != null) {
            sb.append(head.val);
            if (head.next != null) sb.append("->");
            head = head.next;
        }
        sb.append("->NULL");
        System.out.println(sb.toString());
    }
}