字节杭州飞书三面凉经

一面（45min）

1、哪个项目挑战更大一点？
2、为什么用Docker？
3、Docker部署用的网络配置？
4、数据库也放在Docker中吗？mysql进程放在宿主机和Docker中区别，优缺点
5、模块的划分，一个模块是一个进程还是多个进程？
6、Docker之间的通信？
7、Nginx怎么做的负载均衡？（√）
8、Java里面synchronized锁的底层实现原理？（√）
9、介绍一下悲观锁、乐观锁、自旋锁，适用场景？（√）
10、一个JVM进程的内存布局空间？（√）
11、函数返回的时候，return语句的执行过程？（x）
12、MVCC的机制？（√）
13、MVCC怎么解决幻读问题的？（√）
14、临键锁的范围是怎么确定的？（？）
15、说一下ReadView？（举了一个例子，我理解的是问这个，√）

算法：找第K大的数。（x，用小顶堆就行）

二面（57min）

1、进程虚拟地址空间如何映射到物理内存？（√）
2、页表的工作机制？缺页异常怎么处理？（√）
3、操作系统对当前内存页进行更新？内存页面置换算法（√）
4、进程在执行过程中有哪些状态，怎么相互转换的？（√）
5、父进程结束的时候如何确保子进程的资源被回收？（√）
6、HTTPS如何确保数据传输过程中数据的安全？（√）
7、HTTP协议的方法，你怎么理解幂等性？（√）
8、Java多线程？找了一段代码，问执行结果（x）

算法
1、剑指 Offer 12. 矩阵中的路径（√）
2、剑指 Offer 10- II. 青蛙跳台阶问题（√）

三面（57min）

1、实习情况
2、项目情况
3、502的错误一般是什么原因导致的？怎么排查
4、504错误什么原因？503呢？
5、Nginx的网络IO模型？有个专有名词（？？）
6、有遇到过Mysql查询慢的情况吗？怎么排查
7、explain的字段？
8、发生外排序（filesort）的根本原因？
9、用过Redis吗？
10、TCP如何最大化利用现有网络带宽？

算法：

给一个局部有序的数组 [6,7,8,9,10,1,2,3,4,5]，再给一个数字，给出下标，不存在返回-1。要求时间复杂度logN以下。

（我觉得有点像【剑指 Offer 11. 旋转数组的最小数字】，希望大佬指出问题，或者给出正确的解法）

public class Solution {
    int find(int[] nums, int k) {
        int left = 0;
        int right = nums.length - 1;
        // 二分查找，只剩下两个数字，就不继续找了
        while (right - left > 1) {
            int mid = left + (right - left) / 2;
            if (k == nums[mid]) {
                return mid;
            } else if (k > nums[mid]) {
                // k大于中间数字，k在右边
                left = mid + 1;
            } else if (k < nums[mid]) {
                // k大于中间数字，不好判断，所以right--
                if (k == nums[right]) {
                    return right;
                }
                right--;
            }
        }
        if (k == nums[left]) {
            return left;
        }
        if (k == nums[right]) {
            return right;
        }
        return -1;
    }
}

更新

经过大佬提醒，三面算法题目为LC33，其实也不难。二分查找的思路基本是对的，但是面试写的确实有问题。

public class Solution1 {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) {
            return -1;
        }
        if (n == 1) {
            return nums[0] == target ? 0 : -1;
        }
        // 因为是旋转排序数组，且元素互不相同，前后元素是可以接起来的
        // 所以，隐含的条件是 num[n-1]<num[0]
        // 那就以nums[0]为分界
        int left = 0;
        int right = n - 1;
        // 二分查找，搜索区间为[left,right]
        while (left <= right) {
            int mid = left + (right - left) / 2;
            // 找到了
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[0] <= nums[mid]) {
                // 说明左边是连续递增的，没有突变
                // 这个时候如果target在[nums[left],nums[mid])区间，就搜索前半段，否则后半段
                if (nums[left] <= target && target < nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                // 突变位于左边，所以，右边是连续递增
                // 这个时候如果target在(nums[mid],nums[right]]，就搜索后半段，否则前半段
                if (nums[mid] < target && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}