🏗️ 架构设计中的性能优化与可扩展性：如何找到平衡点？ ⚖️

好事发生

  这里推荐一篇实用的文章：《CQRS 与 Event Sourcing：如何高效处理复杂业务场景！》，作者：【喵手】。

  这篇文章作者主要讲解在软件架构设计中，当我们面临着高并发、高复杂度的业务场景时，通常传统的 CRUD（增删改查）模型会显得捉襟见肘。因为在复杂的系统中，读写分离、事件驱动和数据一致性问题往往会给系统设计带来巨大的挑战。此时，CQRS（Command Query Responsibility Segregation） 和 Event Sourcing 就成为了两种强大的架构模式，它们能够帮助我们更好地处理这些挑战。那么，这两种模式到底是如何运作的？在什么情况下它们特别有效？如何设计一个基于这两种模式的系统？今天我们就一起深入探讨这些问题，带你理解如何用 CQRS 和 Event Sourcing 高效处理复杂的业务需求...借此好文安利给大家。

  OK，那本期正文即将拉开帷幕。

🏆本文收录于「滚雪球学Java」专栏中，这个专栏专为有志于提升Java技能的你打造，覆盖Java编程的方方面面，助你从零基础到掌握Java开发的精髓。赶紧关注，收藏，学习吧！

环境说明：Windows 10 + IntelliJ IDEA 2021.3.2 + Jdk 1.8

前言 🔥

在现代软件架构中，性能和可扩展性是两个密切相关但有时互相矛盾的目标。开发人员通常面临着这样的抉择：如何在保证系统性能的同时，保持它在面对更大流量时的可扩展性？性能和可扩展性是每个架构师和开发人员都需要权衡的两大因素，尤其是在分布式系统和高流量环境中，如何找到这两者之间的最佳平衡点，是一个极具挑战性的问题。

本文将深入探讨如何在架构设计中实现高性能，同时又能保障系统的可扩展性，尤其在分布式架构和大流量场景下，如何选择合适的策略进行优化。

性能与可扩展性的权衡 🧐

性能的定义：响应速度与吞吐量

性能通常指的是系统在单位时间内能够处理的工作量，它包括了响应速度（如请求的延迟）和吞吐量（如每秒处理的请求数）。性能优先的架构往往强调在给定硬件资源下，尽可能提高响应速度和吞吐量，从而使得用户能更流畅地使用应用。

然而，追求性能往往意味着需要使用一些技巧和技术来优化资源使用，例如缓存、数据库索引、并发处理等。这些优化有时会导致系统的复杂性增加，或者在某些情况下降低了系统的灵活性。

可扩展性的定义：应对增长的能力

可扩展性是指系统在处理更大流量时，能够灵活扩展资源以维持性能的能力。可扩展的系统可以通过水平扩展（增加更多服务器）或垂直扩展（提升单台机器的硬件性能）来应对流量的增长。分布式架构设计是提升系统可扩展性的一种重要方式。

然而，可扩展性通常要求设计上的额外复杂性，例如分布式数据存储、负载均衡、服务发现等。这些措施可能会带来额外的延迟或增加系统的管理难度。

性能与可扩展性的冲突

性能与可扩展性之间的矛盾往往体现在系统的架构设计上。例如，当我们采用缓存或单点存储系统来提升性能时，可能会导致系统在需要水平扩展时遇到瓶颈；反之，如果我们为了可扩展性采用分布式系统，可能会牺牲性能，因为跨服务和网络调用会引入额外的延迟。

分布式架构中的高性能设计 🔧

在分布式架构中，高性能的实现往往需要考虑多个方面的优化。以下是一些关键策略：

1. 数据分片（Sharding）

数据分片是分布式数据库中的常见手段，它可以将数据按某些规则（如用户 ID、时间戳等）分布到不同的存储节点上。这不仅能够减轻单个节点的负载，还能提高并发处理能力，从而提升性能。

但是，数据分片也会带来额外的挑战，如跨分片查询的复杂性和一致性问题。因此，设计时要特别注意分片策略的选择，并确保在系统增长时能够灵活调整。

2. 缓存机制

缓存是提升性能的经典策略。在分布式架构中，缓存可以减少重复计算和数据库访问，显著提高读取速度。常见的缓存方案如 Redis 和 Memcached，它们支持分布式部署，可以在多个节点之间共享缓存数据。

然而，缓存也带来挑战，尤其是在缓存失效或数据一致性方面。使用缓存时需要特别注意数据的过期策略、缓存穿透和缓存雪崩等问题。

3. 异步处理与消息队列

在高负载和高并发场景下，系统的性能瓶颈往往出现在同步操作上。通过引入异步处理和消息队列（如 Kafka、RabbitMQ），可以将一些耗时的操作（如邮件发送、日志记录、文件处理等）移到后台处理，从而释放主线程，提高系统的响应速度。

不过，异步处理增加了系统的复杂性，特别是在消息队列的可靠性和消息顺序问题上，需要保证系统能够正确处理消息丢失和重复消费等问题。

大流量环境中的负载均衡策略 ⚡

当系统面临大流量时，负载均衡成为了性能和可扩展性之间平衡的重要工具。负载均衡的目标是将用户的请求均匀地分配到多个服务器上，以避免单一节点的过载。

1. 轮询与加权轮询（Round Robin & Weighted Round Robin）

轮询是最简单的负载均衡算法，它将请求依次分配给服务器。如果各服务器的能力相当，轮询是一种高效且简单的选择。

加权轮询则是基于服务器的处理能力设置权重，将更多请求分配给能力强的服务器，适用于不同服务器性能差异较大的场景。

2. 最少连接（Least Connections）

最少连接算法根据当前连接数最少的服务器来分配请求。当服务器的负载差异较大时，这种算法能够有效地避免某些服务器过载。

但是，最少连接算法适合处理请求时长较短的情况，长时间请求可能导致负载不均衡，因此需要根据业务特点选择合适的策略。

3. 基于内容的负载均衡（Content-Based Load Balancing）

在一些高流量场景中，可能需要根据请求的具体内容进行负载均衡。例如，针对静态资源的请求（如图片、CSS 文件）可以直接分配给一组专门处理静态资源的服务器，而动态请求（如数据库查询）则可以分配给另一组服务器。这样的策略可以提高服务器的处理效率，并减轻高负载请求对性能的影响。

如何选择合适的平衡点？ 🤔

在架构设计中，性能和可扩展性并非孤立的目标，二者必须结合系统的具体需求来选择合适的平衡点。以下是一些具体的建议：

1. 了解业务需求

在做架构决策时，首先要明确业务的核心需求。若系统需要低延迟的响应，可能需要优先考虑性能优化；若系统需要处理海量的数据或流量，扩展性可能是更为重要的考量点。

2. 渐进式扩展

许多时候，架构优化不一定要一次性完成，而是可以根据实际需求逐步扩展。例如，在初期可以使用单机架构来满足性能需求，随着流量增长，再逐步引入分布式架构来保证系统的可扩展性。

3. 使用合适的技术栈

选择合适的技术栈也是平衡性能和可扩展性的关键。例如，采用 Redis 缓存和 Kafka 消息队列，可以有效减轻数据库压力；而使用容器化技术和 Kubernetes 集群，则可以更加灵活地扩展系统资源。

4. 持续监控与优化

性能优化与可扩展性的平衡不是一次性的工作，而是一个持续的过程。通过持续监控系统的运行状态，定期进行性能调优，能够帮助我们及时发现瓶颈并进行调整，从而保持良好的系统性能和可扩展性。

1. 分布式架构中的性能优化

数据分片 (Sharding)

假设我们有一个电商系统，用户数据量非常庞大，因此我们需要对用户数据进行分片。这里我们通过将用户 ID 作为分片键，来分配数据到不同的数据库实例。

代码示例：数据分片

// ShardService.java
public class ShardService {

    private static final int SHARD_COUNT = 4; // 假设分成4个分片
    private static final String[] SHARD_DATABASES = {
        "dbShard1", "dbShard2", "dbShard3", "dbShard4"
    };

    // 根据用户ID选择分片
    public String getShardDatabase(int userId) {
        int shardIndex = userId % SHARD_COUNT;
        return SHARD_DATABASES[shardIndex];
    }

    // 获取用户信息
    public User getUser(int userId) {
        String shardDatabase = getShardDatabase(userId);
        // 这里可以根据 shardDatabase 获取对应的数据库连接并查询数据
        System.out.println("Fetching user from: " + shardDatabase);
        return fetchFromDatabase(shardDatabase, userId);
    }

    private User fetchFromDatabase(String shardDatabase, int userId) {
        // 模拟从分片数据库中获取用户数据
        return new User(userId, "User_" + userId);
    }
}

在这个示例中，getShardDatabase 方法根据用户 ID 来选择使用哪个分片数据库。在实际使用中，数据库可以是独立的，也可以是不同的表或者数据库实例。

缓存机制 (Caching)

使用缓存可以显著提高性能，避免频繁访问数据库。以下是一个基于 Redis 的简单缓存实现，当请求用户数据时，我们首先检查缓存中是否存在数据，如果没有再去数据库中查询并缓存结果。

代码示例：使用 Redis 缓存

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.beans.factory.annotation.Autowired;

@Service
public class UserService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private ShardService shardService;

    // 获取用户信息，首先检查缓存
    public User getUser(int userId) {
        String cacheKey = "user:" + userId;
        // 从缓存中获取用户信息
        String cachedUser = redisTemplate.opsForValue().get(cacheKey);
        if (cachedUser != null) {
            System.out.println("Cache hit! Returning from cache.");
            return new User(userId, cachedUser);
        }
        // 缓存未命中，从数据库中获取并缓存
        User user = shardService.getUser(userId);
        redisTemplate.opsForValue().set(cacheKey, user.getName());
        return user;
    }
}

在这个示例中，我们通过 StringRedisTemplate 检查缓存中是否有该用户的名称，如果缓存命中，则直接返回。如果缓存未命中，则从数据库获取用户数据，并将其存入 Redis 缓存中。

异步处理 (Asynchronous Processing)

为了提高性能，可以将一些耗时的操作（如文件处理、邮件发送）异步化。使用 @Async 注解可以将方法异步执行，从而不阻塞主线程。

代码示例：异步邮件发送

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class EmailService {

    @Async
    public void sendEmail(String emailAddress, String subject, String message) {
        // 模拟邮件发送
        System.out.println("Sending email to: " + emailAddress);
        try {
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Email sent to: " + emailAddress);
    }
}

在 EmailService 中，我们使用了 @Async 注解来异步执行 sendEmail 方法，避免了邮件发送阻塞主线程。这对于提高系统的响应速度至关重要。

2. 负载均衡策略

轮询负载均衡 (Round Robin)

轮询负载均衡是最简单的一种方式。以下是一个简单的负载均衡器实现，能够根据请求的顺序轮流将请求分配到多个服务器。

代码示例：轮询负载均衡

import java.util.List;
import java.util.ArrayList;

public class RoundRobinLoadBalancer {

    private List<String> servers;
    private int currentIndex;

    public RoundRobinLoadBalancer(List<String> servers) {
        this.servers = servers;
        this.currentIndex = 0;
    }

    // 获取下一个服务器
    public String getNextServer() {
        String server = servers.get(currentIndex);
        currentIndex = (currentIndex + 1) % servers.size();
        return server;
    }
}

在这个示例中，RoundRobinLoadBalancer 将请求轮流分配到各个服务器。通过简单的 currentIndex 索引来跟踪当前分配到哪个服务器。每次调用 getNextServer 时，都会返回下一个服务器。

代码解析

在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段代码展示了一个 轮询负载均衡器（Round Robin Load Balancer）的实现。轮询负载均衡是一种简单的负载均衡算法，每次请求轮流分配到服务器列表中的不同服务器上，直到所有服务器都分配一次，然后再次从头开始分配。下面是代码的详细解析：

类 RoundRobinLoadBalancer

import java.util.List;
import java.util.ArrayList;

public class RoundRobinLoadBalancer {
    private List<String> servers;  // 服务器列表
    private int currentIndex;      // 当前选择的服务器索引

    public RoundRobinLoadBalancer(List<String> servers) {
        this.servers = servers;
        this.currentIndex = 0;  // 初始化当前索引为 0
    }

    // 获取下一个服务器
    public String getNextServer() {
        String server = servers.get(currentIndex);  // 获取当前索引位置的服务器
        currentIndex = (currentIndex + 1) % servers.size();  // 更新索引，确保循环
        return server;
    }
}

主要字段

• servers: 存储服务器的列表，类型是 List<String>，其中每个字符串代表一个服务器的标识（通常是服务器的 IP 或域名）。
• currentIndex: 用来跟踪下一个要选择的服务器索引，初始化为 0，表示从第一个服务器开始。

构造方法

public RoundRobinLoadBalancer(List<String> servers) {
    this.servers = servers;
    this.currentIndex = 0;  // 初始化索引为 0
}

• 该构造方法接收一个服务器列表 servers，并将其赋值给 this.servers。同时，currentIndex 被初始化为 0，表示从服务器列表的第一个元素开始。

getNextServer 方法

public String getNextServer() {
    String server = servers.get(currentIndex);  // 获取当前索引位置的服务器
    currentIndex = (currentIndex + 1) % servers.size();  // 更新索引，确保循环
    return server;
}

• 获取当前服务器：首先通过 currentIndex 从 servers 列表中获取当前服务器。
• 更新索引：currentIndex = (currentIndex + 1) % servers.size(); 用于确保在访问完所有服务器后，索引回到 0 重新开始。使用 currentIndex + 1 来循环增加索引，并通过 mod 操作（% servers.size()）来确保索引在服务器列表的范围内。
• 返回服务器：返回当前选择的服务器。

工作流程

1. 请求分发：
   • 每次调用 getNextServer() 时，都会返回当前索引位置的服务器，并更新 currentIndex，使其指向下一个服务器。如果当前服务器列表已被轮询完毕，currentIndex 会重新回到 0。
2. 平滑分配：
   • 轮询负载均衡器将每个请求均匀地分配到所有服务器上，适合负载均衡较均匀的场景，尤其是当所有服务器性能相同或接近时。

示例使用场景

假设有 3 台服务器，分别为 Server1、Server2 和 Server3，调用 getNextServer() 时会依次轮询返回：

public class LoadBalancerTest {
    public static void main(String[] args) {
        List<String> servers = new ArrayList<>();
        servers.add("Server1");
        servers.add("Server2");
        servers.add("Server3");

        RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(servers);

        // 模拟请求分发
        System.out.println(loadBalancer.getNextServer());  // Server1
        System.out.println(loadBalancer.getNextServer());  // Server2
        System.out.println(loadBalancer.getNextServer());  // Server3
        System.out.println(loadBalancer.getNextServer());  // Server1 (重新开始轮询)
    }
}

输出：

Server1
Server2
Server3
Server1

优缺点分析

优点：

1. 简单高效：轮询算法简单实现，适合负载相对均衡的环境。
2. 均匀分配请求：所有服务器都会依次收到请求，适合服务器能力大致相同的场景。

缺点：

1. 忽略服务器负载：轮询算法无法考虑每台服务器的当前负载情况，只是简单地将请求平均分配，这对于负载不均的服务器（如某些服务器可能负载较高）来说，可能导致不平衡。
2. 不适合服务器性能差异较大的场景：如果有的服务器性能明显比其他服务器强，轮询负载均衡就无法根据服务器性能做出优化。

改进建议

1. 加权轮询：可以为每台服务器分配一个权重，根据服务器的性能来调整其被选中的频率。例如，性能较好的服务器可以被选中的概率更高。
2. 动态调整：如果服务器负载不均，可以引入实时健康检查和负载监控，动态调整服务器的权重或选取策略。
3. 集成其他策略：可以结合其他负载均衡算法（如最少连接数、随机选择等）进行组合使用，根据业务需求选择合适的策略。

总之，轮询负载均衡是一种简单但有效的负载均衡方法，适用于服务器性能相似、负载均衡需求较为简单的场景。

基于请求最少连接的负载均衡 (Least Connections)

负载均衡器也可以根据当前连接数最少的服务器来分配请求，这样可以避免某些服务器过载。下面是一个简单的实现方式：

代码示例：最少连接负载均衡

import java.util.List;
import java.util.ArrayList;

public class LeastConnectionsLoadBalancer {

    private List<Server> servers;

    public LeastConnectionsLoadBalancer(List<Server> servers) {
        this.servers = servers;
    }

    // 获取连接数最少的服务器
    public Server getNextServer() {
        Server selectedServer = null;
        int minConnections = Integer.MAX_VALUE;

        for (Server server : servers) {
            if (server.getConnections() < minConnections) {
                minConnections = server.getConnections();
                selectedServer = server;
            }
        }

        // 为选中的服务器增加连接数
        if (selectedServer != null) {
            selectedServer.addConnection();
        }
        return selectedServer;
    }

    // 释放服务器连接
    public void releaseServer(Server server) {
        server.releaseConnection();
    }
}

// 服务器类
class Server {
    private String ip;
    private int connections;

    public Server(String ip) {
        this.ip = ip;
        this.connections = 0;
    }

    public int getConnections() {
        return connections;
    }

    public void addConnection() {
        this.connections++;
    }

    public void releaseConnection() {
        this.connections--;
    }

    public String getIp() {
        return ip;
    }
}

在 LeastConnectionsLoadBalancer 类中，我们遍历所有服务器，选出连接数最少的服务器进行请求处理。每当请求分配到一个服务器后，该服务器的连接数会增加，当请求结束时，连接数会减少。

代码解析

在本次的代码演示中，我将会深入剖析每句代码，详细阐述其背后的设计思想和实现逻辑。通过这样的讲解方式，我希望能够引导同学们逐步构建起对代码的深刻理解。我会先从代码的结构开始，逐步拆解每个模块的功能和作用，并指出关键的代码段，并解释它们是如何协同运行的。通过这样的讲解和实践相结合的方式，我相信每位同学都能够对代码有更深入的理解，并能够早日将其掌握，应用到自己的学习和工作中。

这段代码展示了一个 最少连接数负载均衡器（Least Connections Load Balancer），用于根据服务器的连接数来选择最适合的服务器进行请求分发。下面是对代码的详细解析：

主要类：LeastConnectionsLoadBalancer

public class LeastConnectionsLoadBalancer {
    private List<Server> servers;

    public LeastConnectionsLoadBalancer(List<Server> servers) {
        this.servers = servers;
    }

    // 获取连接数最少的服务器
    public Server getNextServer() {
        Server selectedServer = null;
        int minConnections = Integer.MAX_VALUE;

        for (Server server : servers) {
            if (server.getConnections() < minConnections) {
                minConnections = server.getConnections();
                selectedServer = server;
            }
        }

        // 为选中的服务器增加连接数
        if (selectedServer != null) {
            selectedServer.addConnection();
        }
        return selectedServer;
    }

    // 释放服务器连接
    public void releaseServer(Server server) {
        server.releaseConnection();
    }
}

1. servers 列表

• List<Server> servers：这是一个存储所有服务器对象的列表，每个 Server 对象代表一台服务器，并记录该服务器的当前连接数。

2. 构造方法

• public LeastConnectionsLoadBalancer(List<Server> servers)：该构造方法用于初始化负载均衡器，接收一个 servers 列表作为参数，列表中包含了所有参与负载均衡的服务器。

3. getNextServer 方法

• 目的：选择当前连接数最少的服务器。
• 实现：
  • 首先，方法声明了两个变量：selectedServer 用于存储选中的服务器，minConnections 用于存储当前连接数最少的服务器的连接数（初始化为最大整数 Integer.MAX_VALUE）。
  • 遍历服务器列表，检查每个服务器的连接数：
    • 如果某个服务器的连接数小于当前的 minConnections，则更新 minConnections 和 selectedServer。
  • 最后，方法调用 selectedServer.addConnection() 为选中的服务器增加连接数（因为此时已将一个请求分发给该服务器）。
• 返回：返回 selectedServer，即连接数最少的服务器。

4. releaseServer 方法

• 目的：释放服务器的连接。
• 实现：调用 server.releaseConnection()，减少指定服务器的连接数。

服务器类：Server

class Server {
    private String ip;
    private int connections;

    public Server(String ip) {
        this.ip = ip;
        this.connections = 0;
    }

    public int getConnections() {
        return connections;
    }

    public void addConnection() {
        this.connections++;
    }

    public void releaseConnection() {
        this.connections--;
    }

    public String getIp() {
        return ip;
    }
}

1. Server 类

• Server 类表示一个服务器对象，包含以下字段：
  • ip：服务器的 IP 地址，标识该服务器。
  • connections：表示该服务器当前的连接数，初始化为 0。

2. 构造方法

• public Server(String ip)：该构造方法用于初始化服务器对象，并设置服务器的 IP 地址。默认连接数 connections 为 0。

3. 方法

• getConnections()：返回服务器当前的连接数。
• addConnection()：将服务器的连接数增加 1，表示当前有一个新的请求被分发到该服务器。
• releaseConnection()：将服务器的连接数减少 1，表示当前的请求已完成，服务器的连接数减少。
• getIp()：返回服务器的 IP 地址。

负载均衡的工作流程

1. 负载均衡器选择服务器：
   • 当请求到达时，getNextServer() 会根据服务器的连接数选择当前连接数最少的服务器，并分配给该服务器。选中的服务器的连接数会增加 1。
2. 释放连接：
   • 当请求处理完毕时，调用 releaseServer() 来释放服务器的连接数，减少其负载。

示例使用场景

假设有 3 台服务器，分别为 Server1、Server2 和 Server3，并且每台服务器的连接数分别为 2、3 和 1。

public class LoadBalancerTest {
    public static void main(String[] args) {
        List<Server> servers = new ArrayList<>();
        servers.add(new Server("192.168.0.1"));
        servers.add(new Server("192.168.0.2"));
        servers.add(new Server("192.168.0.3"));

        LeastConnectionsLoadBalancer loadBalancer = new LeastConnectionsLoadBalancer(servers);

        // 模拟请求分发
        System.out.println(loadBalancer.getNextServer().getIp());  // 192.168.0.3
        System.out.println(loadBalancer.getNextServer().getIp());  // 192.168.0.1
        System.out.println(loadBalancer.getNextServer().getIp());  // 192.168.0.2

        // 释放连接
        loadBalancer.releaseServer(servers.get(0));  // 释放 Server1 连接
    }
}

进一步的改进建议

1. 线程安全：
   • 如果 LeastConnectionsLoadBalancer 会在多线程环境下使用，需要考虑并发访问问题。可以使用 synchronized 或者更高级的并发控制方法来保证线程安全。
2. 高可用性：
   • 可以扩展负载均衡器支持健康检查（Health Check），确保请求只分发给健康的服务器。
3. 权重调整：
   • 当前的负载均衡器只考虑连接数，未来可以考虑根据其他因素调整负载均衡策略，比如服务器的处理能力、响应时间等。
4. 自适应负载均衡：
   • 负载均衡器可以根据不同服务器的负载情况动态调整策略，例如引入权重机制、最小响应时间策略等。

通过这样的设计，负载均衡器能够有效地分配请求，从而提高系统的资源利用率并避免某台服务器过载。

总结 🎯

通过上述代码示例，我们详细展示了如何在分布式架构中实现性能优化和可扩展性。关键的优化措施包括：

• 数据分片：根据分片键选择不同的数据库或服务器，分担负载。
• 缓存机制：通过缓存热点数据减少数据库查询，提高读取性能。
• 异步处理：将耗时操作异步化，减少主线程阻塞。
• 负载均衡策略：根据不同的负载均衡算法（如轮询、最少连接）合理分配请求。

这些策略有助于在高并发和大流量环境下保持系统的高效运行，同时保证系统具备良好的扩展性和可维护性。

☀️建议/推荐你

  无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学Java」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门Java编程，就像滚雪球一样，越滚越大，指数级提升。

  码字不易，如果这篇文章对你有所帮助，帮忙给bug菌来个一键三连(关注、点赞、收藏) ，您的支持就是我坚持写作分享知识点传播技术的最大动力。   同时也推荐大家关注我的硬核公众号:「猿圈奇妙屋」 ；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有！

📣关于我

  我是bug菌，CSDN | 掘金 | 腾讯云 | 华为云 | 阿里云 | 51CTO | InfoQ 等社区博客专家，历届博客之星Top30，掘金年度人气作者Top40，51CTO年度博主Top12，掘金等平台签约作者，华为云 | 阿里云| 腾讯云等社区优质创作者，全网粉丝合计30w+ ；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板等海量资料。

-End-