likes
comments
collection
share

查漏补缺第六期(京东一面)

作者站长头像
站长
· 阅读数 39

前言

目前正在出一个查漏补缺专题系列教程, 篇幅会较多, 喜欢的话，给个关注❤️ ~

本专题主要以Java语言为主, 好了, 废话不多说直接开整吧~

Kafka的应用场景有哪些，在项目里是如何应用的

Kafka 是一个高吞吐量、可扩展的分布式流处理平台，主要用于构建实时数据流应用程序和数据管道。以下是一些Kafka的应用场景：

  1. 日志收集和聚合：Kafka 可以作为集中式日志收集系统，从多个分布式应用程序中收集日志数据并将其聚合在一起。通过使用 Kafka，可以轻松地实现实时的日志分析、监控和故障排除。

  2. 消息队列：Kafka 提供了高吞吐量的消息传递机制，可以作为消息队列系统使用。应用程序可以将消息写入 Kafka 主题，并由消费者实时读取和处理这些消息。这在构建异步通信系统、任务队列和事件驱动架构时非常有用。

  3. 流式处理：Kafka 具备流式处理的能力，可以通过将数据流传输到 Kafka 主题中，并使用流处理框架（如 Apache Flink、Apache Spark 等）对数据进行实时处理和分析。这对于实时大数据分析、实时仪表盘、实时推荐系统等场景非常有用。

  4. 事件溯源：Kafka 可以用作事件溯源系统的基础设施，用于捕获和存储应用程序中发生的事件。通过将所有事件写入 Kafka 主题，可以方便地回放和重放事件，以便进行数据重现、调试和审核。

  5. 指标和日志流处理：Kafka 可以用作处理指标和日志流的平台。应用程序可以将指标数据和日志消息发送到 Kafka 中，并使用流处理工具进行实时监控、聚合和分析。这有助于实时监控系统的性能、收集统计信息和实现告警系统。

  6. 数据集成和系统解耦：Kafka 可以在不同的应用程序之间充当数据集成和消息传递层，实现系统解耦和松耦合。通过将数据发布到 Kafka 主题，各个应用程序可以独立地消费所需的数据，从而实现系统的可扩展性和灵活性。

总的来说，Kafka 可以应用于许多实时数据处理和流式数据管道场景，旨在处理大规模的实时数据流，提供高可靠性、可扩展性和持久性的数据传输和处理能力。

当面试官问到在公司项目中如何实现 Kafka 的时候，可以参考以下步骤回答,这道题比较灵活，可以根据自己的知识储备进行回答：

  1. 项目需求和场景：首先，描述项目中使用 Kafka 的具体需求和应用场景。例如，您可以提到日志收集、实时数据处理、消息队列、事件驱动等方面的需求。

  2. 架构设计：解释项目中 Kafka 的架构设计。说明 Kafka 在整个系统中的角色和位置，包括 Kafka 的生产者、消费者和主题的概念。您可以提到 Kafka 集群的配置、分区策略、副本机制等。

  3. 生产者端：描述如何在项目中实现 Kafka 生产者。说明项目中哪些组件或模块会向 Kafka 发送消息，并如何使用 Kafka 客户端库（如 Spring Kafka）来发送消息到指定的主题。

  4. 消费者端：说明项目中如何实现 Kafka 消费者。讨论哪些组件或模块会从 Kafka 中消费消息，并如何使用 Kafka 客户端库来接收和处理消息。您可以提到使用 @KafkaListener 注解或手动消费消息的方式。

  5. 消息处理和逻辑：讲述项目中对于从 Kafka 接收到的消息的处理逻辑。说明消费者是如何解析和处理消息的，可能涉及到数据转换、业务逻辑的处理、持久化等操作。

  6. 容错和可靠性：强调项目中如何确保 Kafka 的容错性和可靠性。提到如何处理消息的重试、错误处理、故障转移以及 Kafka 提供的数据持久化机制（如数据日志持久化、消息复制等）。

  7. 性能优化和监控：讨论项目中对于 Kafka 性能优化和监控的措施。说明是否有对 Kafka 进行性能调优、扩展和优化的实践，并提及项目中使用的监控工具或指标，如 Kafka 的吞吐量、延迟等。

  8. 项目成果和收益：总结项目中使用 Kafka 的成果和收益。强调 Kafka 在项目中所带来的价值，如提高系统的实时性、可扩展性、数据一致性等方面的好处。

通过这样的回答，可以回答出在公司项目中对于 Kafka 的理解和实践，并突出项目中使用Kafka的关键点和价值。记得在回答过程中结合具体的项目经验和技术细节，展示您的实际能力和对 Kafka 的深入了解。

Bitmap底层

很多同学不知道它是个啥玩意,下面给大家说下

Bitmap 是一种常用的数据结构，用于高效地表示和操作大量的布尔值。在Java中，可以使用位运算和数组来实现 Bitmap 的底层原理。

底层原理的关键点如下：

  1. 位存储：Bitmap 使用位来表示每个布尔值，通常使用整数类型的数组来存储位数据。每个位的值可以是 0 或 1，分别表示 false 和 true。

  2. 位索引与数组索引的映射：Bitmap 中的每个位都有一个唯一的位索引，用于表示该位在位图中的位置。通常使用位索引除以整数的位宽（比如 32）来得到对应的数组索引，以及位索引对位宽取模的结果来得到在该数组元素中的偏移量。

  3. 位操作：通过位操作（位运算）来设置、获取和修改位值。常用的位操作包括位与（AND）、位或（OR）、位异或（XOR）等。

  4. 初始化：创建 Bitmap 时，需要确定需要表示的布尔值范围，并根据范围初始化底层数组的大小。

  5. 设置位值：通过将位索引对应的位位置为 1，表示相应的布尔值为 true。

  6. 获取位值：通过获取位索引对应的位的值，可以判断相应的布尔值是 true 还是 false。

  7. 扩展和缩小：如果需要表示的布尔值范围超过了初始大小，需要对底层数组进行扩展。类似地，如果范围缩小了，可以对底层数组进行缩小。

总结起来，Bitmap 的底层原理是使用整数类型的数组来存储位数据，通过位索引和位运算来表示和操作布尔值。它具有高效的内存利用和快速的位操作能力，适用于对大量布尔值进行快速查询和修改的场景。

需要注意的是，在 Java 中实现 Bitmap 时，由于 Java 的整数类型是有符号的，需要注意位操作时的符号扩展问题。可以使用无符号右移操作（>>>）来避免符号扩展。

下面简单的实现一下:

public class Bitmap {
    private int[] bitmap;

    public Bitmap(int size) {
        bitmap = new int[size];
    }

    public void setBit(int index) {
        int arrayIndex = index / 32;
        int bitOffset = index % 32;
        bitmap[arrayIndex] |= (1 << bitOffset);
    }

    public boolean getBit(int index) {
        int arrayIndex = index / 32;
        int bitOffset = index % 32;
        return (bitmap[arrayIndex] & (1 << bitOffset)) != 0;
    }

    public void expandBitmap(int newSize) {
        if (newSize <= bitmap.length * 32) {
            return;
        }

        int[] newBitmap = new int[newSize / 32 + 1];
        System.arraycopy(bitmap, 0, newBitmap, 0, bitmap.length);
        bitmap = newBitmap;
    }

    public static void main(String[] args) {
        int size = 64;
        Bitmap bitmap = new Bitmap(size);

        bitmap.setBit(5);
        bitmap.setBit(10);
        bitmap.setBit(30);

        System.out.println("Bit 5: " + bitmap.getBit(5));
        System.out.println("Bit 10: " + bitmap.getBit(10));
        System.out.println("Bit 30: " + bitmap.getBit(30));
        System.out.println("Bit 20: " + bitmap.getBit(20));

        int newSize = 128;
        bitmap.expandBitmap(newSize);

        System.out.println("Bit 120: " + bitmap.getBit(120));

        // Bit 5: true
        // Bit 10: true
        // Bit 30: true
        // Bit 20: false
        // Bit 300: true
        // Bit 120: false
    }
}

在这个示例中，我们创建了一个 Bitmap 类，它包含一个整型数组 bitmap 来存储位数据。在构造函数中，我们初始化了指定大小的位图数组。

  • setBit() 方法用于设置指定索引位置的位为 1，它首先根据索引计算出对应的数组索引和位偏移量，然后使用位运算将对应位位置为 1。

  • getBit() 方法用于获取指定索引位置的位值，它也根据索引计算出数组索引和位偏移量，并通过位运算判断对应位是否为 1，从而返回布尔值。

  • expandBitmap() 方法用于扩展位图数组的大小。如果新的位图大小大于当前数组容量，它会创建一个新的数组，并将原数组的内容复制到新数组中。

在 main() 方法中，我们创建了一个 Bitmap 对象，并演示了设置位值、获取位值和扩展数组大小的操作。输出结果将显示设置的位值和数组扩展后的结果。

扩展: 给定一个包含40亿个随机排列的32位整数的顺序文件，找出一个不在文件中的32位整数，在内存足够的情况下，如何解决这个问题?

存储 40 亿个随机排列的 32 位整数，我们可以进行如下计算：

每个整数占用 32 位，即 4 字节。

由于 byte 类型的数组大小以字节为单位，每个字节可以表示 8 个位。

因此，我们需要的 byte[] 数组大小为：

40 亿 × 4 字节 ÷ 8 = 20 亿字节

转换为更常见的单位，即：

20 亿字节 ÷ (1024 × 1024 × 1024) ≈ 1.86 GB

因此，大约需要 2 GB 的内存来存储这样的 Bitmap。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FindMissingInteger {
    // 这里使用 long 类型来存储以避免溢出。
    long requiredBytes = 2L * 1024 * 1024 * 1024; // 2GB
    int arraySize = (int) (requiredBytes / Byte.SIZE);
    
    public static void main(String[] args) {
        byte[] bitmap = new byte[(int) (arraySize)];

        // read and set 
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                int num = Integer.parseInt(line);
                int byteIndex = num / 8;
                int bitOffset = num % 8;
                bitmap[byteIndex] |= (1 << bitOffset);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        // find
        for (int i = 0; i < MAX_BITMAP_SIZE; i++) {
            int byteIndex = i / 8;
            int bitOffset = i % 8;
            if ((bitmap[byteIndex] & (1 << bitOffset)) == 0) {
                System.out.println("Missing integer: " + i);
                break;
            }
        }
    }
}

假如说我们不使用bitmap来存储大约要多少内存空间呢?我们来计算一下

根据每个整数占用 32 位（4 字节），40 亿个整数的总字节数为：

40 亿 × 4 字节 = 160 亿字节

转换为更常见的单位，即：

160 亿字节 ÷ (1024 × 1024 × 1024) ≈ 14.90 GB

因此需要大约 15GB ~16GB 的内存来存储

Object里有哪些方法

在 Java 中，所有类都继承自 java.lang.Object 类，因此，几乎所有的对象都会具有以下 Object 类的方法：

  1. equals(Object obj): 比较对象是否相等。
  2. hashCode(): 返回对象的哈希码值。
  3. toString(): 返回对象的字符串表示。
  4. getClass(): 返回对象的运行时类。
  5. notify(): 唤醒正在等待该对象监视器的单个线程。
  6. notifyAll(): 唤醒正在等待该对象监视器的所有线程。
  7. wait(): 导致当前线程等待，直到另一个线程调用 notify() 或 notifyAll() 唤醒它。
  8. wait(long timeout): 导致当前线程等待，直到另一个线程调用 notify()、notifyAll() 或超过指定的时间。
  9. wait(long timeout, int nanos): 导致当前线程等待，直到另一个线程调用 notify()、notifyAll() 或超过指定的时间，并且可接受额外的纳秒精度等待时间。

除了上述方法外，Object 类还有一些其他方法，例如 finalize()、clone() 等。另外，还可以通过继承 Object 类自定义一些方法。

需要注意的是，子类可以重写 Object 类中的这些方法以提供特定的行为。因此，在具体的类中，方法的行为可能会有所不同。

线程中有哪些状态，如何转化的?

这个之前讲多线程专题的时候给大家详细讲过一些实例，这里给大家再梳理一下

在 Java 中，线程具有以下几种状态：

  1. 新建状态（New）：当线程对象被创建但尚未调用 start() 方法时，线程处于新建状态。
  2. 运行状态（Runnable）：当线程调用 start() 方法后，线程进入运行状态，可以执行任务。
  3. 阻塞状态（Blocked）：在某些情况下，线程可能会被阻塞，无法继续执行。例如，当线程等待某个锁或者调用 Thread.sleep() 方法时，线程会进入阻塞状态。
  4. 等待状态（Waiting）：线程在等待某个特定条件时进入等待状态。例如，通过调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法，线程可以进入等待状态。
  5. 超时等待状态（Timed Waiting）：类似于等待状态，但是有一个超时时间。例如，通过调用 Thread.sleep()、Object.wait(timeout) 或 Thread.join(timeout) 方法，线程可以进入超时等待状态。
  6. 终止状态（Terminated）：线程执行完任务或者发生异常后，线程进入终止状态。

线程在不同状态之间的转换如下：

  • 新建状态（New）：线程对象被创建。
  • 运行状态（Runnable）：调用线程对象的 start() 方法。
  • 阻塞状态（Blocked）：当线程等待获取某个锁时或调用 Thread.sleep() 方法时。
  • 等待状态（Waiting）：调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法。
  • 超时等待状态（Timed Waiting）：调用 Thread.sleep()、Object.wait(timeout) 或 Thread.join(timeout) 方法。
  • 运行状态（Runnable）：当等待的条件满足或者超时时间结束后，线程会重新进入运行状态。
  • 终止状态（Terminated）：线程执行完任务或者发生异常。

需要注意的是，线程状态的转换是由 Java 虚拟机（JVM）内部进行管理的，程序员无法直接控制线程状态的转换，而是通过合适的方法调用和条件等待来影响线程状态的转换。

Jvm内存模型有了解过吗?说说看

Java 虚拟机（JVM）的内存模型架构由以下组成部分：

  1. 堆内存（Heap Memory）：堆内存是 JVM 中最大的一块内存区域，用于存储对象实例和数组。它是所有线程共享的内存区域。堆内存可以通过参数 -Xmx 和 -Xms 进行调整。

  2. 方法区（Method Area）：方法区是 JVM 的一部分，用于存储类信息、静态变量、常量池、方法字节码等数据。它也是所有线程共享的内存区域。

  3. 程序计数器（Program Counter）：程序计数器是当前线程所执行的字节码指令的地址指示器。每个线程都有独立的程序计数器。

  4. 虚拟机栈（VM Stack）：虚拟机栈用于存储线程的方法调用和局部变量。每个线程在创建时都会分配一个对应的栈，用于保存方法调用过程中的局部变量、参数和返回值。每个方法在执行时都会创建一个栈帧，并入栈执行。

  5. 本地方法栈（Native Method Stack）：本地方法栈与虚拟机栈类似，用于执行本地方法（使用本地语言编写的方法）。它与虚拟机栈的作用相似，但存储的是本地方法调用相关的信息。

  6. 常量池（Constant Pool）：常量池是方法区的一部分，用于存储编译器生成的常量、符号引用和字面量。它包含类和接口的常量、字段和方法的符号引用等。

  7. 直接内存（Direct Memory）：直接内存不是 JVM 运行时数据区的一部分，但也与内存模型有关。它是使用 java.nio 包中的 NIO 类库时，通过 ByteBuffer 分配的一块内存。直接内存的分配不受 JVM 堆的限制。

这些内存区域的组织和使用方式，以及线程对它们的访问和操作规则，共同构成了 JVM 的内存模型架构。这个架构保证了多线程环境下的内存访问和操作的正确性、可见性和有序性，确保了程序的正确执行。

结束语

大家可以针对自己薄弱的地方进行复习, 然后多总结，形成自己的理解，不要去背~

本着把自己知道的都告诉大家，如果本文对您有所帮助，点赞+关注鼓励一下呗~

相关文章

项目源码(源码已更新 欢迎star⭐️)

往期设计模式相关文章

设计模式项目源码(源码已更新 欢迎star⭐️)

Kafka 专题学习

项目源码(源码已更新 欢迎star⭐️)

ElasticSearch 专题学习

项目源码(源码已更新 欢迎star⭐️)

往期并发编程内容推荐

推荐 SpringBoot & SpringCloud (源码已更新 欢迎star⭐️)

博客(阅读体验较佳)

转载自:https://juejin.cn/post/7236563012533108773
评论
请登录