好未来sre面经

好未来sre

CDN

DNS（域名系统）底层使用的是UDP（用户数据报协议）。

服务器响应慢怎么排查

1. 检查网络连接：确保服务器与网络连接稳定，没有网络故障或带宽限制。可以尝试使用其他设备或工具测试网络连接。

2. 检查服务器资源利用率：查看服务器的 CPU、内存和磁盘利用率，确保没有资源瓶颈导致响应延迟。使用系统监控工具或命令可以获取这些信息。

3. 分析日志文件：查看服务器的日志文件，特别是应用程序和网络服务的日志，以确定是否有错误或异常情况发生。错误日志和访问日志可能会提供有关响应慢的线索。

4. 测试数据库性能：如果应用程序使用数据库，可以测试数据库的性能。检查数据库查询的执行计划和索引情况，确保数据库优化良好，没有慢查询或大量并发导致的性能问题。

5. 检查第三方服务：如果应用程序依赖于外部服务或 API，确保这些服务正常运行，并且没有响应延迟或故障。可以尝试与这些服务进行单独的连接测试。

6. 考虑缓存和优化：使用缓存技术可以减少服务器负载和响应时间。考虑在适当的地方使用缓存，以提高响应速度。此外，对代码和查询进行优化可以改善性能。

7. 进行负载测试：模拟高负载情况，使用负载测试工具对服务器进行测试，以找出性能瓶颈和极限。这可以帮助确定服务器在高负载下的表现，并找出导致响应慢的原因。

8. 更新软件和补丁：确保服务器上的操作系统、应用程序和相关软件都是最新版本，并且已经应用了安全补丁和更新。

9. 考虑水平扩展：如果以上步骤无法解决问题，可以考虑通过增加服务器数量或使用负载均衡技术来实现水平扩展，以提高系统的整体性能和响应能力。

1.TCP/IP模型哪四层

2.OSI七层模型为什么会衍生出四层

对SRE的理解

SRE的核心目标是确保在线服务的可靠性和可用性。

SRE（Site Reliability Engineering）是一种软件工程实践方法，旨在将软件开发和运维（可靠性）的最佳实践相结合，以确保系统的可靠性、可扩展性和高效性。

SRE 的核心目标是确保在线服务的可靠性，并通过自动化和工程化的方式来实现这一目标。SRE 团队通常由开发人员和运维工程师组成，他们共同负责设计、构建和运维大规模分布式系统。

以下是 SRE 的一些关键原则和实践：

1. 可靠性目标设定：SRE 强调将可靠性作为核心目标，并定义服务水平指标（SLI）和服务水平目标（SLO）来衡量和评估系统的可靠性。

2. 自动化运维：SRE 倡导使用自动化工具和流程来减少人为错误，提高效率，并确保系统以可预测和可重复的方式运行。

3. 监测和警报：SRE 强调建立全面的监测系统，收集关键指标和日志数据，并设置警报机制以及相应的响应和修复流程。

4. 容量规划和伸缩：SRE 关注系统的容量规划和伸缩能力，通过监测和预测负载，及时进行资源调整和扩展，以满足用户需求。

5. 故障管理和恢复：SRE 强调快速识别和解决故障，实施有效的故障恢复和事后分析，以减少影响并改进系统的鲁棒性。

6. 紧急响应和持久改进：SRE 强调建立紧急响应机制，有效处理系统故障和紧急情况，并持续进行改进，以防止未来类似问题的发生。

自动化和工具的使用，监控和度量，扩容，故障处理等

socker通信

socker通信的流程，数据到服务器是先到哪。

在Socket通信中，数据从客户端发送到服务器的流程如下：

1. 客户端创建一个Socket对象，并指定服务器的IP地址和端口号。通过调用Socket的构造函数，客户端与服务器建立起TCP连接。

2. 客户端使用Socket对象的输出流（OutputStream）将要发送的数据写入。数据可以是字节流或字符流形式。

3. 数据从客户端的输出流经过TCP协议进行分割和封装，并通过网络传输到服务器。底层的网络协议栈负责将数据从客户端发送到服务器，通过路由器和交换机等网络设备传递。

4. 数据到达服务器后，服务器的操作系统接收到数据并将其传递给相应的Socket。操作系统根据服务器的IP地址和端口号来确定将数据传递给哪个Socket。

5. 服务器端的Socket对象通过其输入流（InputStream）接收数据。服务器从输入流中读取数据，并进行相应的处理，例如解析请求、执行业务逻辑等。

6. 服务器通过Socket的输出流将响应数据写回客户端。响应数据经过TCP协议的分割和封装，通过网络传输回客户端。

7. 客户端接收到服务器的响应数据，通过Socket的输入流读取数据。客户端从输入流中解析响应，获取所需的数据。

不同进程内存空间冲突是怎么解决，可以通过以下几种方式进行解决：

进程间通信 (Inter-Process Communication, IPC)：使用IPC机制可以实现进程间的数据交换和通信，而不需要直接访问对方进程的内存空间。常见的IPC机制包括管道、消息队列、共享内存和套接字等。通过这些机制，进程可以安全地共享数据或传递消息，而不会引起内存空间冲突。

远程过程调用 (Remote Procedure Call, RPC)：RPC允许进程在不同的内存空间中调用远程的过程或函数，就像本地调用一样，而无需直接访问对方进程的内存。RPC通过序列化参数、网络传输和反序列化结果来实现远程调用，确保数据的安全传输和返回。

文件或数据库共享：进程可以使用文件或数据库来共享数据，而不需要直接访问对方进程的内存。进程可以将需要共享的数据写入文件或数据库，并通过读取和写入操作来实现数据的共享和同步。

消息传递：进程可以通过消息传递的方式进行通信和数据交换。每个进程拥有自己的内存空间，通过发送和接收消息来传递数据和指令。这种方式可以避免直接访问其他进程的内存空间，从而避免内存冲突。

进程隔离和虚拟化：使用进程隔离和虚拟化技术，可以将不同进程运行在独立的虚拟环境中，每个进程拥有自己的内存空间。这样可以确保不同进程之间的内存空间不会相互冲突。

需要根据具体的应用场景和需求选择适当的解决方案。不同的方案可以根据进程间的关系、数据共享需求和安全性要求等进行选择和组合，以解决进程间的内存空间冲突问题。

Linux

查看内存使用情况

服务器内存使用情况：free

free -m --查看内存，不带单位 free -h --查看内存使用情况，带单位，显示查看结果(对于新手来说这个更详细些)

执行以下命令来查看内存使用情况：

Copy Codefree -h

输出结果示例：

        total        used        free      shared  buff/cache   available
Mem:           7.8G        3.4G        2.0G        194M        2.4G        4.0G
Swap:          2.0G        2.1M        2.0G

在输出结果中，used表示已使用的内存，free表示可用的空闲内存。

查看端口连接情况

使用 netstat 命令:

netstat（网络统计）是一个命令行工具，可以显示网络连接、路由表、接口统计等信息。

查看所有正在监听的端口:

netstat -tuln 查看所有正在建立的连接:

netstat -tun 使用 ss 命令:

ss（socket statistics）是一个用来查看网络和套接字统计的工具，与 netstat 类似，但更为强大和快速。

查看所有正在监听的端口:

ss -tuln 查看所有正在建立的连接:

ss -tun 使用 lsof 命令:

lsof（list open files）可以显示所有打开的文件和网络连接。

查看所有网络连接:

lsof -i 查看特定端口（例如端口80）的使用情况:

lsof -i :80

合并两个有序数组

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1,p2 = n - 1;
        int index = m + n - 1;
        int cur;
        while(p1 > -1 || p2 > -1){
            if(p1 == -1){
                cur = nums2[p2--];//此时nums1已经全部添加到sorted数组当中
            }else if(p2 == -1){
                cur = nums1[p1--];//此时nums2已经全部添加到sorted数组当中
            }else if(nums1[p1] > nums2[p2]){
                cur = nums1[p1--];//nums1更小，所以添加到sorted数组当中
            }else{
                cur = nums2[p2--];//nums2更小，所以添加到sorted数组当中
            }
            nums1[index--] = cur;
        }
        
    }
}

故障场景

SRE 可能面对的各种故障场景和解决方法因系统和环境而异，但以下是一些常见的故障场景和相应的解决方法：

1. 硬件故障：硬件故障可能导致服务器、网络设备或存储设备的故障。解决方法可以包括使用冗余设备和备份系统，以及实施监测和自动故障转移机制。

2. 网络问题：网络问题可能导致服务的可用性和性能下降。解决方法包括监测网络连接和延迟，使用冗余网络路径和负载均衡技术，以及实施容错和重试机制。

3. 软件错误：软件错误可能包括代码缺陷、配置错误或依赖库的问题。解决方法可以包括实施良好的软件工程实践，如代码审查、单元测试和持续集成，以及实施监测和错误追踪机制。

4. 配置问题：配置错误可能导致系统行为异常或不一致。解决方法包括使用配置管理工具和自动化流程来管理和验证配置，以及实施配置审计和版本控制。

5. 容量问题：容量不足可能导致系统性能下降或服务不可用。解决方法包括进行容量规划和预测，监测系统负载和资源使用情况，以及实施自动化的扩展和缩减机制。

6. 第三方服务故障：依赖的第三方服务故障可能影响系统的功能和性能。解决方法包括实施容错和降级策略，使用备用服务提供商或备用机制，以及建立监测和警报机制。

7. 安全漏洞和攻击：安全漏洞和恶意攻击可能导致数据泄露、服务中断或系统瘫痪。解决方法包括实施安全审计和漏洞扫描，采用安全开发实践和加密技术，以及建立安全监测和响应机制。

8. 自然灾害：自然灾害如地震、洪水或暴风雨可能导致数据中心或基础设施的故障。解决方法包括实施灾备和容灾计划，建立分布式和冗余的基础设施，以及进行定期的灾难恢复演练。

Java反射的原理

Java 反射是指在运行时动态地检查、获取和操作类的信息，包括类的属性、方法和构造函数等。通过反射，可以在运行时获取类的结构信息并进行操作，而不需要在编译时知道类的具体细节。

Java 反射的原理主要涉及以下几个关键概念和步骤：

1. Class 对象：Java 中的每个类都有一个对应的 Class 对象，它包含了类的结构信息。通过反射，可以获取和操作这些 Class 对象。

2. 获取 Class 对象：可以通过多种方式获取 Class 对象，包括使用类名调用 Class.forName() 方法、使用类的 .class 属性、或者使用对象的 getClass() 方法。

3. 类的结构信息：通过 Class 对象，可以获取类的属性、方法、构造函数等结构信息。例如，可以使用 getFields() 方法获取公共属性，getMethods() 方法获取公共方法，getConstructors() 方法获取公共构造函数等。

4. 动态创建对象：通过 Class 对象的 newInstance() 方法，可以动态地创建类的实例对象。这相当于调用了类的无参构造函数。

5. 方法调用：通过反射，可以调用类的方法。可以使用 getMethod() 方法获取方法对象，并使用 invoke() 方法调用方法。需要注意的是，如果是私有方法，需要先调用 setAccessible(true) 方法设置为可访问。

6. 字段操作：通过反射，可以获取和设置类的字段值。可以使用 getField() 方法获取字段对象，并使用 get() 和 set() 方法获取和设置字段值。同样需要注意，如果是私有字段，需要先调用 setAccessible(true) 方法设置为可访问。

Java 反射的原理是基于 JVM 的运行时环境和类加载机制实现的。在运行时，JVM 会加载类的字节码文件，将类的信息存储在内存中，并创建对应的 Class 对象。通过反射，可以在运行时获取这些 Class 对象，并通过 Class 对象获取和操作类的结构信息，实现动态的类加载和运行时操作。

需要注意的是，反射虽然提供了灵活的动态操作能力，但过度使用反射可能会导致代码可读性和性能上的损失。因此，在使用反射时需要谨慎考虑，并权衡使用的必要性和影响。

单例模式

单例模式的实现有多种方式，如下所示：

1、懒汉式，线程不安全

是否 Lazy 初始化：是

是否多线程安全：否

实现难度：易

描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。 这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

接下来介绍的几种实现方式都支持多线程，但是在性能上有所差异。

2、懒汉式，线程安全

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：易

描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。 优点：第一次调用才初始化，避免内存浪费。 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。 getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

3、饿汉式

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

描述：这种方式比较常用，但容易产生垃圾对象。 优点：没有加锁，执行效率会提高。 缺点：类加载时就初始化，浪费内存。 它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

4、双检锁/双重校验锁（DCL，即 double-checked locking）

JDK 版本：JDK1.5 起

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：较复杂

描述：这种方式采用双锁机制，安全且在多线程情况下能保持高性能。 getInstance() 的性能对应用程序很关键。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
            if (singleton == null) {  
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

共享内存：

共享内存是一种用于进程间通信的机制，它允许多个进程访问和操作同一块内存区域。通过共享内存，进程可以直接读取和写入共享内存区域中的数据，而无需进行显式的数据复制或消息传递。这种通信方式可以提供高效的数据交换和通信速度，特别适用于需要频繁交换大量数据的场景。

在共享内存中，多个进程可以通过内存映射的方式将同一块物理内存映射到各自的虚拟地址空间中。这样，它们可以通过读写自己虚拟地址空间中的内存来实现对共享内存的访问。由于多个进程同时访问同一块内存区域，因此需要进行适当的同步和互斥操作，以保证数据的一致性和正确性。

共享内存的优点包括：

1. 高效性：由于数据直接存储在共享内存中，进程间数据的传输和复制开销较小，可以实现高速的数据交换。

2. 简单性：相对于其他进程间通信机制，如管道或消息队列，共享内存的实现相对简单，使用方便。

3. 实时性：共享内存提供了实时数据共享的能力，适用于对实时性要求较高的应用场景。

然而，共享内存也存在一些潜在的问题和注意事项：

1. 同步和互斥：由于多个进程同时访问共享内存，需要进行适当的同步和互斥操作，以避免数据竞争和一致性问题。

2. 安全性：共享内存可能导致安全性问题，特别是在多个进程之间共享敏感数据时，需要采取额外的安全措施，如加密或访问控制。

3. 跨平台兼容性：共享内存的实现可能受限于操作系统和硬件平台的限制，需要考虑跨平台兼容性的问题。

4. 内存管理：共享内存需要进行适当的内存管理，包括内存分配和释放等操作，避免内存泄漏或悬挂指针等问题。

总的来说，共享内存是一种高效的进程间通信机制，适用于需要频繁交换大量数据的场景。但在使用共享内存时，需要注意同步和互斥操作、安全性和内存管理等方面的问题。

在共享内存中进行同步和互斥操作，以确保多个进程对共享数据的访问是有序且正确的。以下是一些常用的方法和技术：

1. 互斥锁（Mutex）：互斥锁是最常见的同步机制之一。它通过在共享内存的关键代码段前后设置锁，确保同一时间只有一个进程可以访问共享数据。其他进程在尝试访问共享数据时会被阻塞，直到锁被释放。

2. 读写锁（Read-Write Lock）：读写锁允许多个进程同时读取共享数据，但在写入数据时需要互斥。这种机制可以提高并发性能，适用于读操作频繁、写操作较少的场景。

3. 条件变量（Condition Variable）：条件变量用于在满足特定条件时进行线程间的通信和同步。当某个条件不满足时，进程可以等待条件变量的通知，从而避免忙等待的情况。

4. 信号量（Semaphore）：信号量是一种计数器，用于控制对共享资源的访问。通过递增或递减信号量的计数值，进程可以申请或释放对共享资源的访问权限。常用的信号量包括二进制信号量（用于互斥访问）和计数信号量（用于资源的限制）。

5. 屏障（Barrier）：屏障用于在多个进程达到某个状态之前进行同步。当所有进程都到达屏障点时，屏障才会打开，进程才能继续执行后续操作。

6. 互斥量（Mutex）、条件变量（Condition Variable）和信号量（Semaphore）等同步机制的组合使用，可以实现更复杂的同步需求。

异步日志

异步日志是一种日志记录的方式，它通过将日志写入磁盘的操作放在后台异步进行，以减少对主线程的阻塞时间，提高系统的性能和响应性。异步日志的异步实现可以通过以下几种方式：

1. 缓冲区：异步日志通常使用一个缓冲区（Buffer）来存储待写入磁盘的日志消息。主线程将日志消息写入缓冲区，然后立即返回，而不需要等待写入磁盘的操作完成。这样可以避免主线程被磁盘写入操作阻塞。

2. 后台线程：异步日志通常会启动一个后台线程（或多个线程），负责将缓冲区中的日志消息异步写入磁盘。后台线程可以周期性地或根据一定的触发条件将缓冲区中的日志刷新到磁盘上。这样，主线程可以继续执行其他任务，而不需要等待磁盘写入操作完成。

3. 队列：异步日志可以使用一个队列（Queue）来实现主线程和后台线程之间的通信。主线程将日志消息放入队列中，而后台线程从队列中读取日志消息并进行写入磁盘操作。队列可以提供线程安全的操作，确保消息的可靠传递。

4. 锁和条件变量：为了保证缓冲区的线程安全性，异步日志通常使用锁和条件变量机制。主线程在写入缓冲区之前需要获取锁，以保证对缓冲区的互斥访问。后台线程在读取缓冲区之前也需要获取锁，并通过条件变量等待主线程的通知。

需要注意的是，异步日志的实现需要考虑线程安全性和数据一致性的问题。主线程和后台线程在访问共享资源（如缓冲区）时需要进行适当的同步和互斥操作，以避免竞态条件和数据错误。此外，后台线程需要保证日志消息的完整性和顺序性，确保所有的日志消息都被正确写入磁盘。

异步日志的实现可以根据具体的需求和技术选型进行选择，常见的实现方式包括使用线程池、事件驱动等技术。在设计和实现异步日志时，需要综合考虑性能、可靠性和复杂度等因素。

我的

线程创建

视频电话出现故障，如何排查

时延处理

计算机网络

二面

网页请求流程

双十一网站设计