一面

开了摄像头，下半年面过的公司中唯一一家公司开摄像头吧

腾讯会议聊天窗口丢了2道题，第一道，2个有序数组排序，没什么难度，高中生都知道思路，写完叫我测试下几个数据，没啥问题，于是叫我发过去给他，于是我直接把文件拖进聊天窗口得了：

import org.junit.Test;

import java.util.Arrays;

/**
 * @date 2023/9/19 20:00
 */
public class Main {
    //给定两个升序数组 len1
    // ，合并为一个新的升序数组 len2
    public int[] solution(int[] nums1, int[] nums2) {
        //判空
        if (nums1 == null || nums1.length == 0) return nums2;
        if (nums2 == null || nums2.length == 0) return nums1;
        //start:
        int len = nums1.length + nums2.length;
        int[] res = new int[len];

        int leftIndex1 = 0;
        int leftIndex2 = 0;
        for (int i = 0; i < len; i++) {
            if (leftIndex1 == nums1.length) {
                res[i] = nums2[leftIndex2];
                leftIndex2++;
                continue;
            }
            if (leftIndex2 == nums2.length) {
                res[i] = nums2[leftIndex1];
                leftIndex1++;
                continue;
            }

            if (nums1[leftIndex1] > nums2[leftIndex2]) {
                res[i] = nums2[leftIndex2];
                leftIndex2++;
            } else {
                res[i] = nums1[leftIndex1];
                leftIndex1++;
            }
        }
        return res;
    }

    @Test
    public void testSolution() {
        int[][] arr = {
//                {1,2,4,5,7},//[-1, 1, 2, 3, 4, 5, 7, 8]
//                {-1,3,8},
//
//
                {4, 44, 123, 26873, 286822},
                {-4, 10, 13, 873, 28682299},//[-4, 4, 10, 13, 44, 123, 873, 26873, 286822, 28682299]

        };
        System.out.println(Arrays.toString(solution(arr[0], arr[1])));
    }
}

2、交替打印1~100，也算简单得了，不过太久没写juc的内容生疏了，写得慢了一些。因为是由很多方式写出来的，面试官就说用你想到的方法写就行。

/**
 * @date 2023/9/19 20:14
 */

public class Solution {
    static ReentrantLock lock = new ReentrantLock();
    static Condition condition1 = lock.newCondition();
    static Condition condition2 = lock.newCondition();

    //5 10 5 10
    public static void main(String[] args) {
        Print obj = new Print();
        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    lock.lock();
                    System.out.print("this is thread 1 : ");
                    int print = obj.print();
                    if (print == 101) break;
                    condition2.signal();
                    condition1.await();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    lock.lock();
                    System.out.print("this is thread 2 : ");
                    int print = obj.print();
                    if (print == 101) break;
                    condition1.signal();
                    condition2.await();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }


    @Test
    public void comeTrueByExecutor() {
        Print obj = new Print();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, 2,
                0, TimeUnit.SECONDS,
                new SynchronousQueue<>(),
                new ThreadPoolExecutor.AbortPolicy());

        Future<Boolean> f1 = executor.submit(() -> {

            while (true) {
                lock.lock();
                try {
                    condition2.signal();
                    condition1.await();
                    System.out.print("Thread-1 , print number is : ");
                    int print = obj.print();
                    if (print == 101) break;
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }

            }

            return true;
        });

        Future<Boolean> f2 = executor.submit(() -> {
            while (true) {
                lock.lock();
                try {
                    condition1.signal();
                    condition2.await();
                    System.out.print("Thread-2 , print number is : ");
                    int print = obj.print();
                    if (print == 101) break;
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
            return true;
        });

        try {
            f1.get();
            f2.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

class Print {
    private int count = 0;
    public int print() {
        if (count == 101) return 101;
        System.out.println(count);
        count++;
        return count;
    }
}

写完也测试下没啥问题，讲解完再发文件给面试官。太久没写，写得冗余代码有点多。。。

1.1、说一下主要线程池主要参数。写的时候因为我提了一句也可以使用线程池创建2个线程来交替打印，于是又问了线程池。

1.2比如说核心线程数5，最大线程数10，什么时候能达到最大线程数？

线程池没什么好讲的，一般都是问的参数，参数之间的关系，答清楚就行，线程池执行任务的流程规律说清楚就行。毕竟又研究过，没啥问题。

四大拒绝策略、优缺点；阻塞队列，应用场景答答就行。

2、叫我翻道上面一点，，问synchronizd和reentrantlock区别，完善的地方：没看过synchronizd的源码，因为是jvm层的锁，得抽时间去再深入下（得去找找哪里可以看得到源码）。reentrantlock事后也研究了。还得自己排练一下，方便表达更流程清晰些。

3、synchronizd底层锁升级逻辑？浅答了一下，有点忘记了。面完复习补上了

4、轻量级锁是怎么样的锁。

5、reentrantlock这块是怎么实现的？答得还不够清晰。事后已研究。

6、Java的hashmap扩容是怎么一个过程？

7、如果说设计一个hash算法有什么需要注意的点？除了解决hash冲突问题的几种算法，我应该还要去答多线程情况等维度怎么处理，尽可能答得深刻、多维度吧，这个是事后反应要完善的地方。

8、redis为什么设计成单线程？多个角度答出来，但是还得去系统查一下这个问题。

9、redis有没有多线程的一些操作？我结合项目、平时使用redis锁观察的一些现象答出来了。事后还得系统盘一下，再深入研究一下。

10、那用lua脚本有什么用？结合上一点我答得内容问的。

11、lua脚本可以执行保证原子行？

redis批量处理的方式都深入研究过了，没啥问题。

12、使用redis过程中有用过zset？

讲完我再讲讲redis的str、hash类型了，都答深入了。都有研究过，事后也复习了一遍。

13、看你了解docker，docker都用在哪些地方？讲了命令，还有一些其他的，比如说数据库之类的都要有挂载啥的，方便崩溃恢复数据。

14、docker之间网络底层实现、网络通信了解过吗？之前看过忘了，就说没了解过吧。

15、mysql事务怎么实现的？

怎么实现？我的话从4大特性的实现去答吧，有点忘记了，会多少答多少吧，锁机制也得答一下。不过没反应过来，从多个维度+个人理解答肯定是没问题的。很容易忘记，得不断复习才行，之前系统研究过得，不过研究不够深，一直想找MySQL源代码的，得抽时间找一下。后续再排练更加清晰流畅些吧。

最后8分钟给介绍了公司技术栈、业务方向。九宫格腾讯医疗健康之类的，事后也去网上调研了下这个部门公司业务之类的。

项目一点没问，可以说基本按照简历问吧。

目前就差粗体字没去加强得了，得找找时间深入研究下。

二面

算是第三个遇到开摄像头的面试官了

没让做题哈哈。

二面问的问题应该是因人而异，看你会啥就问啥吧，尽可能主动暴漏自己擅长的点给面试官问就行，我刚好有在些自媒体做过些分享也刚好做过面试官也是写博客的，所以这个契机下就根据我分享的技术里问了。虽然打断我了，但是还是围绕在自己会的点上，感觉还是hold得主的。

1、自我介绍时我讲了我有在B站做视频，于是问我是做哪方面的？巴拉巴拉巴拉。可以用什么关键字搜索到？

2、你这些都是自己弄的视频吗？我看你在csdn也做个人博客，博客可能更早发。于是我介绍了一些平时写博客，做技术up的一些经历。

挑了些B站发布过的视频。正好挑中了一个之前作业的视频，正好那个视频我也只是把作业简单做做，所以没啥深入的，大三的作业懂得抖动，而且不是和开发相关的。于是直接说细节忘了。

看你对springboot的接触的较多一些。

事后反省：虽然没问springboot那些框架，但投大厂还是把没经常看源码的点去掉吧。再把大厂简历给改了，没系统深入研究的东西别写！

3、看你对写了不少对redis的东西是吧？答了一会儿

日常你对redis是用来干什么的？这里就讲了自己项目里运用到的一些情况，包括优化、数据类型选型、其他redis类型的像比较、优化百分比等等。讲了十分钟不止吧。

4、听你说的内容中，lua脚本和pipeline的根本区别是什么？

让我陷入了沉思吧，这种问题，对于有很多区别的2种技术，必定是有很多区别是吧，但是最根本的到底是什么呢？我选择了从不同角度回答吧，但是这么多角度中哪一个是最根本的区别？面试官的意思就是问那个最根本的区别的那个点。这个问题我觉得从答案就在源码里，可惜没看到那儿，只能结合之前的研究答了，后面去研究发现应该是没答错，但还不够齐全。得去深入再研究下。

5、如果说redis在执行一段lua脚本，那么redis是如何处理其他的一些查询？或者说怎么处理其他的一些请求？我说不能处理，因为执行lua脚本会将其他操作阻塞住。

6、（结合上一个问题）为什么会阻塞住？你觉得为什么执行lua脚本的时候会执行一些其他的请求？lua脚本执行时时会阻塞其他操作的，更深入没研究过的，感觉类似于又问到源码、又问到了人生意义的时候了。。。

于是我类比其他一些命令为什么会阻塞住推断一下答了单线程、为什么要用单线程以及为什么lua要执行耗时短的一些原因等等之类的。

答得过程中又插一句：redis执行时大多数都是单线程的？我继续讲了下去讲了几点，应该是没啥问题

因为我答过程中聊到了线程上下文切换的恢复现场以及维护现场环境，于是又去问我这些参数是啥，有点忘记了，反正是数据区域存储的是什么？因为我很久前写过汇编就提了一嘴，于是就只能照着记忆答了。

 复盘：针对每个任务，在其创建的时候都会在栈内开辟一段固定大小的空间用来保存任务的上下文（包括CPU状态，运行栈，内部寄存器） 参考https://www.codeleading.com/article/99925463023/

感觉不太好检索答案，不过汇编相关资料肯定可以找得到，晚点再去看吧。

7、你刚才说redis设计成单线程为了避免上下文切换开销，那么为什么Java又要设计成多线程呢？问得感觉开放飞起，一般开放题还真很难遇到也没仔细想过（普通公司也不会问太难），只能按照自己的理解来了，这种问题在以后也需要强化的。

8、既然lua脚本不能执行耗时过长的命令，那么假如说我有段原子行操作、耗时也很长，那怎么处理？就靠之前看过得文章类似的场景来回答吧，答了2三点，没啥问题，但是我觉得这中场景题还是看少了，得多去学学。而且答出2三点对于普本而言没啥机会的。

9、结合上一个回答中说提过一嘴的bigkey于是问说说bigkey的危害？这个之前看过，但是忘了细节，只能结合自己的储存记忆以及比如业务、用户体验等角度来答吧.

10、因为上一个回答提到sds，问那么Java里面有什么数据结构或类和redis的sds类似的呢?还真没想！结合自己的去答，应该是那3个string吧（string、stringbuilder、stringbuffer），于是又讲了一会。

11、在上一个问题继续深入：或者说在扩容方面和哪个比较像？

12、说说stringbuilder是怎么扩容的呢？

10-12临时去想还真答不完善，事后再去重新系统深入研究这几点吧。

13、zset?他这个问zset基本都可以秒了。

基本上是1小时吧，回头看录音才发现问了这么久。。。

那我这边基本没什么问题了，你这边有什么要问的吗？

剩下6分钟反问，就不展示反问的了

晚点再去深入复习或研究那些问题吧。

感觉二面只针对个人的特色自己会的点来问的。打断自我介绍，算是面过的第一家公司第一次打断吧，这种在面试中挺正常，因为大厂都uncare这些，也有些面试官风格是这样的，其实打不打断无所谓，围绕你会的点去问的话对面试者就很友好，打断了也没有围绕就比如第三面吧。项目没问，是uncare吧，但是也不算没问，把项目、八股文等其他内容全部杂糅到一块了，怎么说呢，就是不问你项目，但是回答问题肯定是可以结合项目的。

感觉就说大厂面试就是每一点都挖的很深直到不会为止，先这样吧

明晚再写三面的凉筋吧