• 【2024秋招】用友项目管理部门java后端二面2023.9.12

    1 rpc框架

    1.1 深入讲讲你做的这个rpc框架

    答：

    1.2 你这个注册中心有实现相关的监控吗

    1.2.1 如何实现注册中心有实现相关的监控

    是的，我可以为你提供关于RPC注册中心及其监控的相关信息。RPC注册中心是用于管理微服务之间调用关系的中心化服务，它可以帮助微服务发现和调用其他服务。而监控是确保微服务健康、稳定运行的重要手段，可以实时检测和报警系统中的异常情况。

    对于RPC注册中心的监控，通常包括以下几个方面：

    1. 服务健康检查：定期检查注册在注册中心的服务是否健康运行，如果服务出现故障，可以及时从注册中心摘除，防止其他服务调用失败。

    2. 服务调用统计：统计每个服务的调用次数、失败次数、平均响应时间等，帮助分析系统的运行状况。

    3. 资源使用情况：监控注册中心自身的CPU、内存、磁盘、网络等资源使用情况，确保注册中心稳定运行。

    4. 数据同步情况：对于集群部署的注册中心，需要监控各节点的数据同步情况，确保数据的一致性。

    5. 报警机制：当监控到异常情况时，可以通过邮件、短信、电话等方式及时通知运维人员。

    常见的RPC注册中心如Zookeeper、Eureka、Consul、Nacos等，它们都提供了一定的监控功能或者有第三方工具支持其监控。

    如果你需要更详细的信息或者对某个具体的RPC注册中心的监控有兴趣，可以告诉我，我会为你提供更多的资料。

    1.2.2 consul和nacos分别如何实现注册中心的监控的

    Consul和Nacos都是流行的服务注册与发现中心，它们都提供了一系列的监控和健康检查机制。以下是它们分别如何实现注册中心的监控的简要描述：

    Consul:

    1. 健康检查：Consul内置了健康检查机制，允许定义多种检查方式，如HTTP、TCP、脚本等。当服务的健康状态发生变化时，Consul会自动更新服务的状态。

    2. UI界面：Consul提供了一个Web UI界面，可以在其中查看集群的健康状态、服务列表、节点信息等。

    3. Metrics接口：Consul提供了一个/metrics HTTP端点，可以获取Consul的运行指标，如请求率、请求延迟、集群领导选举次数等。

    4. 集成第三方监控工具：Consul的指标可以与Prometheus、Grafana等监控工具集成，以提供更丰富的监控视图和报警机制。

    5. 日志：Consul可以输出详细的日志，帮助诊断问题。

    Nacos:

    1. 健康检查：Nacos也提供了健康检查机制，可以定期检查服务的健康状态，并根据结果更新服务的状态。

    2. 控制台：Nacos提供了一个管理控制台，可以在其中查看服务列表、健康状态、配置信息等。

    3. Metrics接口：Nacos也提供了指标接口，可以获取Nacos的运行指标。

    4. 集成第三方监控工具：Nacos的指标可以与Prometheus、Grafana等监控工具集成。

    5. 日志：Nacos可以输出详细的日志，帮助运维人员诊断问题。

    6. 扩展性：Nacos提供了丰富的扩展点，允许用户自定义健康检查逻辑、数据源等。

    总的来说，Consul和Nacos都提供了完善的监控和健康检查机制，可以确保服务的健康和稳定。但具体的实现细节和功能可能会有所不同，需要根据实际需求选择合适的工具。

    1.2.3 详细讲讲consul和nacos实现注册中心健康检查的过程

    当我们谈论服务注册中心的健康检查，我们主要是指如何确定注册的服务实例是否健康、是否能够正常提供服务。Consul和Nacos都提供了健康检查的机制，但它们的实现方式和细节有所不同。以下是Consul和Nacos实现健康检查的详细过程：

    Consul:

    1. 定义健康检查：在Consul中，服务可以在注册时定义其健康检查的方式。这些方式包括HTTP、TCP、脚本和TTL。

      • HTTP：Consul会定期向指定的HTTP端点发送请求，根据响应的HTTP状态码判断服务的健康状态。
      • TCP：Consul会尝试建立到指定的TCP端口的连接，如果连接成功，则认为服务是健康的。
      • 脚本：Consul会定期执行指定的脚本，并根据脚本的退出状态判断服务的健康状态。
      • TTL：服务需要在指定的TTL时间内向Consul发送心跳，否则Consul会认为服务不健康。

    2. 健康状态更新：当服务的健康状态发生变化时，Consul会自动更新服务的状态。例如，如果一个服务的健康检查失败，Consul会将该服务标记为不健康，并从服务发现的结果中排除该服务。

    3. 健康状态查询：用户可以通过Consul的API或UI查询服务的健康状态。

    Nacos:

    1. 心跳机制：Nacos主要依赖于心跳机制来检查服务的健康状态。当服务实例注册到Nacos后，它需要定期向Nacos发送心跳来表示它仍然是活跃的。

    2. 心跳超时：如果Nacos在指定的时间内没有收到服务实例的心跳，它会认为该服务实例不健康，并将其从服务列表中移除。

    3. 健康状态查询：用户可以通过Nacos的控制台或API查询服务的健康状态。

    4. 健康检查扩展：Nacos提供了健康检查的扩展点，允许用户自定义健康检查的逻辑。

    总结：Consul提供了多种健康检查的方式，可以根据服务的特性选择合适的方式。而Nacos主要依赖于心跳机制来检查服务的健康状态，但它也提供了健康检查的扩展点，允许用户自定义健康检查的逻辑。两者都能够有效地确保服务的健康和稳定。

    1.3 你整个的这个rpc调用，有考虑过它的限流嘛

    对于一个QPS为2的服务，我们可以使用令牌桶、漏桶和滑动窗口计数器算法来实现限流。以下是每种算法的简单实现：

    1.4 比如现在有两个服务，比如说qps只有2，现在达到限流的目的，分别使用令牌桶、漏桶和滑动窗口计数器算法，你如何实现呢

    答：

    1. 令牌桶算法：

    • 初始化一个容量为2的桶，并以每500ms放入一个令牌的速率填充桶。
    • 当请求到来时，尝试从桶中取出一个令牌。
      • 如果取出成功，请求继续。
      • 如果取出失败（桶中无令牌），请求被限制。
    import java.util.concurrent.locks.ReentrantLock;

public class TokenBucket {
    private final int capacity;
    private int tokens;
    private long lastRefillTime;
    private final int refillRate;
    private final ReentrantLock lock = new ReentrantLock();

    public TokenBucket(int capacity, int refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
        this.tokens = capacity;
        this.lastRefillTime = System.currentTimeMillis();
    }

    public boolean tryConsume() {
        lock.lock();
        try {
            refill();
            if (tokens > 0) {
                tokens--;
                return true;
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

    private void refill() {
        long now = System.currentTimeMillis();
        int tokensToAdd = (int) ((now - lastRefillTime) / 1000 * refillRate);
        if (tokensToAdd > 0) {
            tokens = Math.min(capacity, tokens + tokensToAdd);
            lastRefillTime = now;
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    2. 漏桶算法：

    • 初始化一个容量为2的桶，并以每500ms处理一个请求的速率流出。
    • 当请求到来时，尝试放入桶中。
      • 如果放入成功，请求继续。
      • 如果放入失败（桶已满），请求被限制。
    import java.util.concurrent.locks.ReentrantLock;

public class LeakyBucket {
    private final int capacity;
    private int water;
    private long lastLeakTime;
    private final int leakRate;
    private final ReentrantLock lock = new ReentrantLock();

    public LeakyBucket(int capacity, int leakRate) {
        this.capacity = capacity;
        this.leakRate = leakRate;
        this.water = 0;
        this.lastLeakTime = System.currentTimeMillis();
    }

    public boolean tryConsume() {
        lock.lock();
        try {
            leakWater();
            if (water < capacity) {
                water++;
                return true;
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

    private void leakWater() {
        long now = System.currentTimeMillis();
        int waterToLeak = (int) ((now - lastLeakTime) / 1000 * leakRate);
        if (waterToLeak > 0) {
            water = Math.max(0, water - waterToLeak);
            lastLeakTime = now;
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    3. 滑动窗口计数器算法：

    • 基于您的描述，我理解您希望使用一个滑动窗口计数器，其中每一秒都有一个独立的计数器。当请求到来时，我们将检查过去1秒内的请求计数。如果这个计数超过2，请求将被限制。

      以下是基于这个想法的Java代码实现：

      import java.util.LinkedList;

public class SlidingWindowRateLimiter {
    private final LinkedList<RequestCounter> counters;
    private final int limit;

    public SlidingWindowRateLimiter(int limit) {
        this.counters = new LinkedList<>();
        this.limit = limit;
    }

    public synchronized boolean tryConsume() {
        long now = System.currentTimeMillis();
        long oneSecondAgo = now - 1000;

        // 清除1秒前的计数器
        while (!counters.isEmpty() && counters.getFirst().timestamp < oneSecondAgo) {
            counters.removeFirst();
        }

        // 获取过去1秒内的请求总数
        int totalCount = counters.stream().mapToInt(c -> c.count).sum();

        if (totalCount < limit) {
            // 如果当前秒的计数器不存在，创建一个
            if (counters.isEmpty() || counters.getLast().timestamp != now / 1000 * 1000) {
                counters.addLast(new RequestCounter(now / 1000 * 1000));
            }
            counters.getLast().count++;
            return true;
        }
        return false;
    }

    private static class RequestCounter {
        long timestamp;
        int count;

        RequestCounter(long timestamp) {
            this.timestamp = timestamp;
            this.count = 0;
        }
    }

    public static void main(String[] args) {
        SlidingWindowRateLimiter limiter = new SlidingWindowRateLimiter(2);
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // false
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51

      这个实现确保在任何给定的1秒窗口内，请求的数量都不会超过2。

    1.5 你给的滑动窗口计数器方案中，qps的速率固定死了，如果说某一个服务有异常，你的qps为2也达不到，只有1呢？而且服务恢复后，qps的速率能不能恢复到2

    我的答案：配置一个灵活的限流器，每次读取限定的qps阈值的时候，可以读取根据从配置中心读取到的参数限制qps，至于是谁发出的调整阈值信号，则应该是注册中心。这种情况应对的是所有的服务调用不走注册中心，也不走负载均衡器或者其他第三方服务器，而是可以直接打到服务提供者，所以限流器得在服务的提供者端生效

    gpt4答案：

    您提到的问题确实是滑动窗口计数器在实际应用中可能会遇到的挑战。为了解决这个问题，我们可以引入动态调整QPS的机制。以下是一个简化的策略：

    1. 动态调整QPS：我们可以根据服务的健康状况动态调整QPS。例如，如果服务出现异常，我们可以降低QPS限制；当服务恢复正常时，我们可以逐渐提高QPS限制，直到达到原始的限制。

    2. 健康检查：我们可以定期检查服务的健康状况。如果服务响应时间增加或失败率上升，我们可以认为服务可能出现了问题，并相应地调整QPS限制。

    3. 平滑恢复：当服务恢复正常后，我们不应该立即将QPS限制提高到原始值，而应该逐渐提高，以确保服务不会再次被过载。

    以下是一个简化的Java代码实现，展示如何动态调整QPS：

    import java.util.LinkedList;

public class DynamicSlidingWindowRateLimiter {
    private final LinkedList<RequestCounter> counters;
    private int currentLimit;
    private final int maxLimit;

    public DynamicSlidingWindowRateLimiter(int maxLimit) {
        this.counters = new LinkedList<>();
        this.currentLimit = maxLimit;
        this.maxLimit = maxLimit;
    }

    public synchronized boolean tryConsume() {
        long now = System.currentTimeMillis();
        long oneSecondAgo = now - 1000;

        // 清除1秒前的计数器
        while (!counters.isEmpty() && counters.getFirst().timestamp < oneSecondAgo) {
            counters.removeFirst();
        }

        // 获取过去1秒内的请求总数
        int totalCount = counters.stream().mapToInt(c -> c.count).sum();

        if (totalCount < currentLimit) {
            if (counters.isEmpty() || counters.getLast().timestamp != now / 1000 * 1000) {
                counters.addLast(new RequestCounter(now / 1000 * 1000));
            }
            counters.getLast().count++;
            return true;
        }
        return false;
    }

    public void adjustLimitBasedOnHealth(boolean isServiceHealthy) {
        if (isServiceHealthy) {
            currentLimit = Math.min(maxLimit, currentLimit + 1);
        } else {
            currentLimit = Math.max(1, currentLimit - 1);
        }
    }

    private static class RequestCounter {
        long timestamp;
        int count;

        RequestCounter(long timestamp) {
            this.timestamp = timestamp;
            this.count = 0;
        }
    }

    public static void main(String[] args) {
        DynamicSlidingWindowRateLimiter limiter = new DynamicSlidingWindowRateLimiter(2);
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // false

        // 假设服务出现异常
        limiter.adjustLimitBasedOnHealth(false);
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // false

        // 假设服务恢复正常
        limiter.adjustLimitBasedOnHealth(true);
        System.out.println(limiter.tryConsume());  // true
        System.out.println(limiter.tryConsume());  // true
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    这只是一个简化的示例，展示了如何根据服务的健康状况动态调整QPS。在实际应用中，可能需要更复杂的策略和实现。

    1.6 实现rpc框架用到了什么序列化协议

    答：protocol buffer，json以及kyro这些序列化协议

    1.7 选择序列化协议时怎么考虑安全性和性能呢？

    选择序列化协议时，安全性和性能都是非常重要的考虑因素。以下是如何在选择序列化协议时考虑这两个方面的建议：

    1. 安全性：

    1. 不可预测性：选择那些不容易被篡改或预测的序列化协议。例如，避免使用那些容易受到反序列化攻击的协议。

    2. 验证和完整性：确保序列化数据在传输和存储时都是完整的，并且没有被篡改。可以使用签名或哈希来验证数据的完整性。

    3. 加密：对敏感数据进行加密，确保只有授权的接收者可以解密和访问数据。

    4. 最小权限原则：只序列化和反序列化那些真正需要的数据，避免暴露不必要的信息。

    5. 库和工具的选择：选择那些经过广泛审查和测试的库和工具，避免使用那些已知存在安全漏洞的库。

    2. 性能：

    1. 大小：选择那些生成小的序列化数据的协议，这样可以减少传输和存储的开销。例如，Protocol Buffers和MessagePack通常比JSON和XML生成更小的数据。

    2. 速度：考虑序列化和反序列化的速度。某些协议，如Protocol Buffers，被优化为快速序列化和反序列化。

    3. 兼容性：选择那些支持向前和向后兼容性的协议，这样可以在不中断服务的情况下升级数据结构。

    4. 易用性：考虑协议的易用性和生态系统。某些协议，如JSON，有广泛的库支持和社区活跃度。

    5. 特性支持：考虑协议支持的特性，如模式验证、默认值、枚举等。

    总的来说，选择序列化协议时需要权衡安全性和性能。在某些情况下，可能需要牺牲一些性能以获得更好的安全性，或者反之。关键是根据具体的应用和需求进行选择，并确保在实施时遵循最佳实践。

    1.8 分别讲一讲json，kyro，hessian以及protobuf这几个序列化协议在安全性上做出了什么保证

    各种序列化协议在设计时都有其特定的目标和应用场景，因此它们在安全性上的保证也各不相同。以下是您提到的几个序列化协议在安全性上的主要考虑：

    1. JSON:

    • 简单性：JSON是一个文本格式，易于阅读和理解。这使得它在安全审查时相对容易。
    • 无执行代码：与某些序列化格式不同，JSON不支持嵌入执行代码，这减少了某些攻击的风险。
    • 注意事项：由于JSON是文本格式，它可能容易受到注入攻击。此外，解析JSON时，如果使用不安全的库或方法，可能会受到各种攻击，如无限递归、大数字攻击等。

    2. Kryo:

    • 高效但不安全：Kryo是为高性能而设计的，但默认情况下并不安全。它可以反序列化任何Java类，这可能导致恶意代码执行。
    • 安全模式：Kryo提供了一个安全模式，可以限制反序列化的类。使用此模式可以增加安全性，但可能牺牲一些灵活性。
    • 注意事项：在使用Kryo时，应始终使用安全模式，并且只允许反序列化已知安全的类。

    3. Hessian:

    • 二进制格式：Hessian是一个二进制RPC编码，设计用于Web服务。
    • 已知的安全问题：在过去，Hessian受到了多种攻击，如远程代码执行。这是因为它允许反序列化任何Java对象。
    • 注意事项：使用Hessian时，应该限制反序列化的类，并使用最新版本的库，以避免已知的安全漏洞。

    4. Protocol Buffers (protobuf):

    • 高效且简单：protobuf是为高效和简单性而设计的。它是一个二进制格式，不支持执行代码。
    • 无执行代码：与JSON类似，protobuf不支持嵌入执行代码。
    • 模式定义：protobuf使用模式定义数据结构，这为数据提供了一定的验证。但它不支持复杂的验证规则。
    • 注意事项：虽然protobuf本身相对安全，但在使用时仍然需要注意数据验证和处理，以避免潜在的安全问题。
    • 不支持任意对象的反序列化：与某些Java序列化库不同，protobuf不支持任意对象的反序列化。它只支持预定义模式中的数据结构，这降低了恶意代码执行的风险。

    总的来说，每种序列化协议都有其优点和缺点。在选择和使用时，应该考虑其安全性，并遵循最佳实践，以确保数据的安全和完整性。

    1.9 注意事项：由于JSON是文本格式，它可能容易受到注入攻击。此外，解析JSON时，如果使用不安全的库或方法，可能会受到各种攻击，如无限递归、大数字攻击等。举几个无限递归、大数字攻击的例子

    • 无限递归：某些JSON解析库可能在处理高度嵌套的JSON结构时遇到问题。例如，一个巨大的、深度嵌套的JSON结构可能导致堆栈溢出。攻击者可以利用这一点发送恶意的JSON数据，导致服务崩溃。
      {
  "a": {
    "b": {
      "c": {
        "d": "@ref:1"
      }
    }
  }
}


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
    • 大数字攻击：某些JSON解析库在处理非常大的数字时可能会遇到问题。例如，JavaScript中的数字是双精度浮点数，其精度有限。如果JSON包含一个超出这个范围的大数字，它可能会被解析为不正确的值，或者导致解析错误。

    1.10 json能不能反序列化任何Java类？

    • JSON本身是一个数据交换格式，它不直接支持Java类的序列化和反序列化。但是，有很多库（如Jackson、Gson等）可以将JSON数据映射到Java对象，或者将Java对象转换为JSON。这种映射通常基于Java对象的字段和JSON的键。
    • 但是，与某些其他序列化格式不同，JSON不支持直接反序列化任意Java类。例如，它不支持Java对象的方法、构造函数或其他非字段属性。因此，使用JSON不容易受到恶意代码执行的攻击。

    1.11 protobuf在安全性上做出了哪些努力，再详细说说

    • 明确的模式：protobuf使用明确的模式定义数据结构。这为数据提供了一定的验证，确保数据的结构和类型与预期相符。
    • 不支持代码执行：与某些其他序列化格式不同，protobuf不支持嵌入执行代码。这降低了恶意代码执行的风险。
    • 高效的二进制格式：protobuf是一个二进制格式，设计为高效且紧凑。这使得它在处理大量数据时更为高效，减少了DoS攻击的风险。
    • 不支持任意对象的反序列化：与某些Java序列化库不同，protobuf不支持任意对象的反序列化。它只支持预定义模式中的数据结构，这降低了恶意代码执行的风险。
    • 版本兼容性：protobuf设计为支持向前和向后兼容性。这意味着即使数据结构发生变化，也可以安全地序列化和反序列化数据。

    1.12 序列化和反序列化的过程中涉及到了加密算法吗，有没有可能被破解

    序列化和反序列化本身是将数据结构或对象转换为可传输或存储的格式的过程，以及将这种格式的数据转换回其原始形式。这个过程本身不涉及加密，但在某些应用场景中，为了数据的安全性，序列化后的数据可能会被加密。

    涉及到加密算法的情况：

    1. 数据传输安全：当序列化的数据需要在不安全的网络中传输时，为了保护数据的隐私性和完整性，可能会使用加密算法对数据进行加密。

    2. 数据存储安全：当序列化的数据需要存储在可能被未经授权的用户访问的位置时，为了防止数据泄露或篡改，可能会使用加密算法对数据进行加密。

    被破解的可能性：

    1. 加密算法的强度：加密算法的强度是决定其是否容易被破解的关键因素。现代的加密算法，如AES、RSA等，在使用适当的密钥长度时，被认为是安全的，即使面对强大的攻击者也很难破解。

    2. 密钥管理：加密算法的安全性在很大程度上取决于密钥的管理。如果密钥被泄露，加密的数据就可能被破解。因此，密钥的生成、存储、分发和销毁都需要特别小心。

    3. 实现错误：即使加密算法本身是安全的，但如果在实现或使用时出现错误，也可能导致数据泄露。例如，使用固定的初始化向量、不正确的填充模式、不安全的随机数生成器等都可能导致加密的弱点。

    4. 旧的或弱的加密算法：使用已知存在漏洞或被认为是弱的加密算法，如DES、RC4等，会增加被破解的风险。

    总的来说，序列化和反序列化的过程中可以涉及到加密算法，但是否使用加密以及如何使用取决于具体的应用场景和安全需求。正确使用现代的加密算法和遵循最佳实践可以大大降低被破解的风险。

    1.13 你在测试这些序列化协议的性能上做了哪些验证和了解，比如压缩比验证和序列化反序列化的时间？（重要）

    答：推荐看这篇文章：An Introduction and Comparison of Several Common Java Serialization Frameworks

    1.14 使用你的rpc框架后，tps测试了嘛（重要）

    答：

    1.15 你的配置中心用什么实现的呢，有没有考虑过封装呢

    答：nacos

    1.16 你在rpc框架里考虑过事务问题嘛，比如A在一个事务内调用B，C，D等多个服务（重要）

    答：使用2PC，3pc分布式事务的方案

    1.17 你有没有考虑在rpc框架这一层面统一解决分布式事务呢？比如说A调用B，B事务是在另一台机器上执行的，执行失败后B会回滚，则你的rpc框架会告诉消费者服务事务B回滚了吗？这样的机制有考虑过嘛？（重点）

    答：

    2 秒杀系统

    2.1 怎么做的压测，压测的tps峰值多少

    答：使用了jmeter测试的，开了1w个线程，模拟1w个用户去访问这个秒杀接口，测试了三轮，然后取到了平均值，在这个阶段tps达到了峰值，并且没有出现过多的丢包情况，但是再增加线程去访问这个接口的时候，就出现了丢包

    2.2 机器的配置

    16GB内存，8核cpu

    2.3 你这个测试的应该只是单个秒杀商品这一个接口吧

    对

    2.4 测试的步长

    2.4.1 在JMeter中，步长通常通过"线程组"中的设置来配置。具体地，您可以使用“线程组”的“线程数”、“启动延迟”和“循环次数”来模拟步长。以下是如何在JMeter中设置步长的步骤：

    1. 打开JMeter：启动JMeter应用。

    2. 添加线程组：右击测试计划 -> 新建 -> 线程组。

    3. 配置线程组：

      • 线程数（Number of Threads）：这是您想要模拟的总用户数。例如，如果您想模拟1万个用户，您可以设置线程数为10,000。
      • 启动延迟（Ramp-Up Period）：这是所有线程启动的总时间。例如，如果您设置线程数为10,000，启动延迟为100秒，那么JMeter将每秒启动100个线程，这就是您的步长。
      • 循环次数（Loop Count）：这是每个线程执行测试计划的次数。通常，对于压测，您可能只想执行一次，但对于持续负载测试，您可能想让线程执行多次。

    4. 其他设置：确保您的线程组中的采样器和其他元素正确配置，以模拟您想要的用户行为。

    5. 启动测试：点击JMeter工具栏上的绿色播放按钮开始测试。

    6. 监控性能：在测试期间，您可以使用JMeter的内置监听器（如“图形结果”、“表格结果”等）来实时监控性能指标。

    请注意，为了获得准确的测试结果，您可能需要根据系统的响应和性能指标调整步长和其他参数。建议在正式测试之前进行预测试，以确定最佳的设置。

    2.4.2 这个过程中，1w个用户，你设计的步长是多长时间（重要）

    因为秒杀系统应对的是高并发流量，步长是无限大，如下所示

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

    2.4.3 线程数1000，启动延迟是0，循环次数是1，合理吗

    您提到的JMeter配置是：线程数1000，启动延迟0，循环次数1。这意味着您将有1000个虚拟用户几乎同时开始执行测试，并且每个用户只执行一次。以下是对这种配置的评估：

    1. 线程数1000：这意味着您想模拟1000个并发用户。这是一个相对较大的并发数，特别是对于某些应用或服务。您需要确保您的测试环境和目标系统可以处理这种并发负载。

    2. 启动延迟0：这意味着所有的虚拟用户都会几乎同时开始。这会在很短的时间内对目标系统产生巨大的压力，可能导致系统瞬时崩溃或性能下降。这种配置可以模拟突发流量或高并发的场景。

    3. 循环次数1：每个虚拟用户只执行一次测试。这意味着测试的总体持续时间可能会很短，特别是如果目标系统的响应时间很快。

    是否合理？

    • 这完全取决于您的测试目的。如果您想模拟一个突发的高并发场景，例如一个新产品的发布或一个广告活动的启动，这种配置可能是合理的。

    • 但如果您想模拟更真实的用户行为，例如用户在不同的时间间隔内逐渐增加，或者用户在一段时间内多次访问应用，那么您可能需要调整配置。

    • 对于大多数应用，突然有1000个用户几乎同时发送请求可能不是一个常见的场景。在这种情况下，逐渐增加用户（即设置一个非零的启动延迟）可能会提供更真实的测试结果。

    总之，这种配置可能对某些测试场景是合理的，但对其他场景可能不是。建议在确定配置之前明确您的测试目的，并根据需要进行调整。

    2.4.4 应该使用什么样的步长的测试

    步长的选择取决于您的测试目的和场景。在某些情况下，小步长可能是理想的，而在其他情况下，大步长可能更合适。以下是关于步长选择的一些建议：

    1. 模拟真实用户行为：如果您的目的是模拟真实的用户流量模式，那么您应该选择一个反映这种模式的步长。例如，如果您的应用在一天中的某个时间段内经常经历流量峰值（例如，每天早上9点），那么您可能希望使用小步长来模拟这种突然的流量增加。

    2. 性能瓶颈和问题定位：如果您的目的是找出系统的性能瓶颈或其他问题，那么逐渐增加负载（即使用较大的步长）可能更有助于识别问题的根源。这是因为系统在不同的负载级别下可能会表现出不同的行为。

    3. 系统的稳定性：如果您知道系统可以轻松处理高并发负载，那么使用小步长（或甚至启动延迟为0）可能是合适的。但是，如果您不确定系统的性能限制，那么逐渐增加负载可能是一个更安全的选择。

    4. 测试的持续时间：小步长可能会导致测试的持续时间增加，因为需要更长的时间才能达到目标负载。如果测试时间有限，您可能需要考虑使用较大的步长。

    总的来说，确实，在系统能够承受的情况下，使用小步长可以更快速地达到目标负载，并更准确地模拟某些真实的用户流量模式。然而，步长的选择应该基于您的测试目的、系统的性能特点和其他考虑因素。

    2.5 如何防止超卖呢

    2.6 etcd

    1. etcd是一个框架吗？

      不，etcd不是一个框架。etcd是一个分布式、可靠的键值存储系统，用于配置管理、服务发现和其他用途，特别是在分布式系统中。它使用Raft协议来保证数据的一致性和高可用性。

    2. etcd的全称？

      etcd没有一个正式的“全称”。名称“etcd”源于"/etc"目录和"distributed"的组合，其中"/etc"目录在Unix-like系统中通常用于存储配置文件。因此，etcd可以被视为一个分布式的"/etc"目录。

    3 讲讲你的本科毕设

    4 反问

    4.1 你们部门

    答：项目云产品部，你之前是有过事务云的面试

    4.2 你们和BIP的区别

    答：项目云是BIP的一部分，有云平台，供应链等等

  • 相关阅读:
    排序算法：插入排序
    Dart 2.18 发布，Objective-C 和 Swift interop
    小程序用vue编写，保存表单出错
    Linux 上的 .NET 如何自主生成 Dump
    Zookeeper选举Leader源码剖析（上）
    【入门篇】1.7 Redis 之 codis 入门介绍
    SpringMvc拦截器
    带你一起玩转—Java 数组
    Node.js如何处理多个请求？
    rust持续学习 raw pointer 1
  • 原文地址：https://blog.csdn.net/yxg520s/article/details/133952645