嵌入式面经篇一

---

前言

记录一些招聘公司在招聘嵌入式软件岗位时的一些问题，此文为第一篇。

---

一、大疆

1、谈谈你对多线程与多进程的理解？

答：多线程与多进程是两种常见的并发执行技术，广泛应用于程序设计中，以提高执行效率和资源利用率。

• 多进程
  • 定义：进程是操作系统分配资源的基本单位，每个进程都拥有自己的独立内存空间和系统资源。
  • 优点：
    • 隔离性强：每个进程拥有独立的内存空间，一个进程崩溃不会直接影响到其他进程。
    • 安全性：由于内存隔离，进程间不会直接影响，减少了数据错误和安全风险。
  • 缺点：
    • 资源消耗大：每个进程需要独立的内存和系统资源，切换成本高。
    • 通信复杂：进程间通信（IPC）需要特定的技术和方法，如管道、消息队列、共享内存等。
• 多线程
  • 定义：线程是进程内的一个执行序列，是操作系统能够进行运算调度的最小单位，它们共享父进程的内存空间和资源。
  • 优点：
    • 资源共享：线程之间可以直接共享内存和文件等资源，通信更简便。
    • 效率高：线程的创建和切换的资源消耗和时间成本远低于进程。
  • 缺点：
    • 安全性问题：共享资源可能导致数据不一致，需要额外的同步和锁定机制。
    • 稳定性差：一个线程崩溃可能影响整个进程的稳定性。
• 应用场景
  • 多进程：适用于任务间需要隔离的情况，如在不同服务之间分配资源，或者在可靠性和安全性要求较高的场合。
  • 多线程：适合于资源使用要求高效且任务间共享大量数据的场景，如服务器的并发处理，或者高频率的任务调度。

2、线程，进程间通信方式

• 线程间通信（线程间的通信通常比较简单，因为所有线程共享相同的内存地址空间。主要的通信方式包括：）
  • 共享内存：线程可以直接访问同一进程内的共享数据。但这种方式需要处理同步问题，防止多个线程同时修改同一数据导致数据不一致。
  • 锁机制：
    • 互斥锁（Mutex）：确保同一时间只有一个线程访问特定的内存或资源。
    • 读写锁：允许多个读操作同时进行，但写操作需要独占访问。
  • 条件变量：允许线程在某些条件下挂起操作，直到其他线程更改条件并通知它继续。
  • 信号量：用于控制对共享资源的访问数量，可以解决生产者-消费者问题等。
• 进程间通信（进程间通信由于涉及到不同的内存空间，方式更为多样和复杂：）
  • 管道（Pipe）：
    • 匿名管道：只能用于具有亲缘关系的进程间通信（如父子进程），单向数据流。
    • 命名管道（FIFO）：可以在无亲缘关系的进程间进行双向通信，但通信效率不如匿名管道。
  • 信号（Signal）：用于处理异步事件，一个进程可以给另一个进程发送信号，受信号影响的进程可进行相应处理。
  • 消息队列：允许一个或多个进程向队列中写入或读取消息。消息存储在内核中，直到被接收。
  • 共享内存：最快的 IPC 方式，多个进程可以访问同一块内存区域。需要同步机制以避免竞争条件。
  • 套接字（Socket）：支持不同机器间的进程通信。适用于网络通信和本地通信。
  • 信号量（Semaphores）：主要用于同步多个进程对共享资源的访问。
  • 内存映射（Memory-mapped files）：使用文件或设备的内存映射区域作为进程间共享数据的方式。

3、有名管道与匿名管道区别？

• 匿名管道
  • 连接方式：只能用于有亲缘关系的进程之间，如父子进程。这是因为它们是在进程创建时由父进程向子进程继承的。
  • 生命周期：存在于进程的生命周期内，一般用于进程的短暂通信。
  • 通信方式：通常是半双工的，即数据只能单向流动，要么从父进程到子进程，要么反之。
  • 文件系统：匿名管道不在文件系统中显示，它们由操作系统直接管理。
  • 创建和使用：通常通过操作系统 API（如 UNIX 的 pipe() 函数）直接创建和使用。
• 有名管道
  • 连接方式：可以在任何两个进程之间使用，无论它们之间是否有亲缘关系。这使得有名管道更加灵活。
  • 生命周期：可以长期存在于系统中，不依赖于任何特定的进程。有名管道在文件系统中以文件的形式存在，即使创建它的进程已经终止，其他进程仍然可以通过文件名访问它。
  • 通信方式：通常是全双工的，支持数据的双向流动。
  • 文件系统：作为特殊文件存在于文件系统中，可以像操作普通文件一样对其进行创建、连接和删除。
  • 创建和使用：通过特定的系统调用（如 UNIX 系统的 mkfifo 命令）创建，进程可以通过打开这个文件来读取或写入数据。

4、说一下条件变量怎么实现？

在 Linux 中，条件变量是一种同步原语，通常与互斥锁（mutexes）一起使用来实现线程间的协调。条件变量允许线程在某些预设条件尚未满足时阻塞自己，直到其他线程改变条件并显式地通知条件变量。这种机制特别适合于生产者-消费者问题和其他需要线程协调的场景。

• Linux 中的条件变量实现
  • 初始化： 使用 pthread_cond_init() 函数初始化条件变量。也可以使用静态初始化的方式 PTHREAD_COND_INITIALIZER。
  • 等待条件（Waiting on the Condition）：
    • 线程通过调用 pthread_cond_wait() 或 pthread_cond_timedwait() 来等待特定的条件满足。在调用这些函数时，线程必须已经获得了与条件变量配合使用的互斥锁。
    • pthread_cond_wait() 会自动释放互斥锁，并使线程进入阻塞状态。当条件变量被通知（或广播）时，线程被唤醒，然后自动重新获取互斥锁。
  • 通知条件（Signaling the Condition）：
    • 另一个线程可以调用 pthread_cond_signal() 或 pthread_cond_broadcast() 来通知一个或所有等待条件变量的线程。
    • pthread_cond_signal() 唤醒等待该条件变量的至少一个线程，而 pthread_cond_broadcast() 唤醒等待该条件变量的所有线程。
  • 销毁条件变量：使用 pthread_cond_destroy() 函数销毁条件变量，释放其所占用的资源。
• 实现细节（在内部实现上，条件变量通常涉及到以下几个关键组件：）
  • 等待队列：系统维护一个等待队列，所有等待条件变量的线程都会被加入到这个队列中。
  • 互斥锁解锁和重锁机制：当线程调用 pthread_cond_wait 时，系统会自动释放互斥锁，并在线程被唤醒并返回前自动重新获取互斥锁。
  • 状态变量：通常需要配合条件变量使用一些状态变量来表示真实的条件状态，确保即使发生虚假唤醒（spurious wakeup），线程也能正确处理其逻辑。

5、信号量机制怎么实现的？该机制可以用于进程间通信吗？信号量机制中PV操作是原⼦操作吗？

信号量是一种重要的同步机制，用于控制对共享资源的访问，可以确保多个线程或进程在访问共享资源时不会发生冲突，被广泛应用于操作系统中的进程或线程同步。

• 信号量的实现
  • 在 Linux 系统中，信号量可以通过 POSIX 信号量或 System V 信号量来实现。
    • POSIX 信号量：这是一种较新的实现，提供了良好的跨平台支持。使用函数 sem_init() 来创建，sem_wait() 和 sem_post() 来执行等待（P 操作，即减少操作）和释放（V 操作，即增加操作）。
    • System V 信号量：这是一种更古老的实现，提供了一组较为复杂的控制功能，如信号量集合，它允许一次操作多个信号量。
• 信号量用于进程间通信
  • 信号量虽然主要用于同步，但也可以间接用于进程间通信（IPC）。信号量可以控制多个进程对共享资源的访问顺序，从而允许它们按照特定的顺序执行操作，间接地传递信息。例如，两个进程可以使用信号量来协调对共享内存的访问，其中一个进程写入数据后通过信号量通知另一个进程数据已经准备好。
• PV 操作是否为原子操作
  • 信号量的 P 操作（sem_wait()）和 V 操作（sem_post()）是设计为原子操作的。这意味着在多线程或多进程环境中，当一个线程或进程在执行这些操作时，不会被其他线程或进程中断。原子性是通过操作系统内核来保证的，确保每次只有一个线程或进程能够修改信号量的值。
    • P 操作（sem_wait()）：如果信号量的值大于零，它会减少信号量的值（表示资源被占用）并继续执行。如果信号量的值为零，则调用线程或进程将被阻塞，直到信号量的值不为零。
    • V 操作（sem_post()）：增加信号量的值（表示释放资源）并唤醒等待该信号量的一个或多个线程或进程。

6、linux中断流程，谈谈你对中断上下文的理解

在 Linux 操作系统中，中断是硬件或软件发出的信号，提示处理器暂停当前正在执行的任务，转而处理紧急事件。中断机制是现代操作系统中处理外部事件的核心技术。对于中断的理解涉及到多个层面，包括中断的类型、处理流程，以及中断上下文的特点。

• 中断的类型
  • 硬件中断：由硬件设备产生，如键盘输入、网络数据到达等。
  • 软件中断：由软件指令产生，如系统调用。
  • 异常：如除零错误、内存访问违规等。
• 中断处理流程（中断处理通常分为两个主要阶段：中断服务例程（ISR）和底半部（Bottom Half）处理。）
  • 中断请求（IRQ）：当硬件设备需要 CPU 注意时，它通过发送信号到一个中断控制器来生成中断请求。中断控制器决定是否发送信号到 CPU，取决于中断的优先级和当前状态。
  • 中断服务例程（ISR）：
    • 保存上下文：当中断发生时，CPU 首先保存当前任务的状态，包括寄存器等关键信息。
    • 执行ISR：执行特定的中断服务例程来处理中断。这一阶段应尽可能快速完成，避免长时间占用 CPU。
  • 任务切换：中断处理完毕后，根据优先级和调度策略选择下一个要执行的任务，并恢复其上下文继续执行。
• 中断上下文（中断上下文指的是在处理中断时，操作系统的运行环境和状态。它与常规的进程上下文有几个关键区别：）
  • 无进程上下文：中断上下文不属于任何一个用户进程。当中断发生时，当前的进程执行被中断，处理器跳转到中断服务程序（Interrupt Service Routine, ISR）执行。在中断上下文中，系统不会保存进程的上下文信息，因此无法执行与具体进程相关的操作，如调度其他进程或访问用户空间内存。
  • 不可阻塞：在中断上下文中，代码不能睡眠或阻塞，因为中断服务程序必须尽快完成。阻塞会导致系统陷入死锁状态，因为中断上下文无法被调度出去，系统就无法继续运行。
  • 优先级高：中断上下文具有高优先级，系统在处理中断时会关闭部分或全部中断，以防止嵌套过多的中断处理。这意味着中断处理程序的执行通常会打断其他较低优先级的任务，从而快速响应事件。
  • 简短执行：中断处理程序应该尽可能快地执行完毕，以减少对系统其他部分的影响。如果中断处理程序执行时间过长，可能导致其他中断的延迟处理，影响系统整体性能。因此，复杂的处理通常会被推迟到中断下半部（例如软中断、tasklet、工作队列）执行。
• 底半部处理
  由于中断处理需要快速完成，一些不那么紧急的任务会被推迟到中断服务之后处理，这部分称为底半部（如任务队列、软中断或工作队列）。这样可以有效地分离紧急处理和次要处理，优化系统响应时间和效率。

7、来谈⼀下 C++ 中多态

在 C++ 中，多态是面向对象编程的核心概念之一，允许对象以接口的共通形式表现出多种形态。在 C++ 中，多态主要分为两种类型：静态多态（编译时多态）和动态多态（运行时多态）。这两种多态的实现和用途有所不同，但都是通过提供统一的接口来处理不同类型的对象。

• ①、静态多态
  • 静态多态主要通过函数重载和模板实现，其决定机制发生在编译时。
    • i. 函数重载
      • 在同一作用域内定义几个函数名相同但参数列表不同的函数。
      • 编译器根据函数调用时的参数类型来决定具体调用哪个函数。
      • 示例

        void print(int i) {
          cout << "Printing int: " << i << endl;
        }
        void print(double f) {
          cout << "Printing float: " << f << endl;
        }
        

    • ii. 模板：
      • 使用模板可以写出与类型无关的代码，编译器根据传入的实际类型生成相应的函数。
      • 示例：

        template<typename T>
        void print(T arg) {
          cout << "Printing: " << arg << endl;
        }
        

• ②、动态多态
  • 动态多态是通过虚函数（Virtual Functions）和继承实现的，其决定机制发生在运行时。
    • i. 虚函数：
      • 在基类中声明函数为虚函数（使用 virtual 关键字），允许在派生类中对其进行重写（Override）。
      • 如果派生类提供了虚函数的新实现，那么通过基类指针或引用调用该函数时，将动态决定调用哪个版本的函数。
      • 示例：

        class Base {
        public:
          virtual void show() { // Virtual function
            cout << "Base class show function called." << endl;
          }
          virtual ~Base() {} // Virtual destructor for proper cleanup
        };
        
        class Derived : public Base {
        public:
          void show() override { // Override the base class function
            cout << "Derived class show function called." << endl;
          }
        };
        

    • ii. 虚析构函数
      • 当删除派生类的对象时，应该声明基类的析构函数为虚函数，以确保正确地调用派生类的析构函数，避免资源泄漏。
      • 示例中的 virtual ~Base() {} 确保了析构过程的正确性。
• ③、用途和优点
  • 代码复用和扩展：多态允许程序员编写可扩展的代码，例如编写操作基类对象的函数，然后自动应用于任何派生类对象。
  • 接口隔离：基类可以定义一个接口，派生类可以以不同方式实现这个接口，但对使用者隐藏实现细节，只暴露统一的接口。
  • 动态绑定：动态多态的运行时绑定允许系统更灵活地处理不同类型的对象，提高了程序的可维护性和扩展性。

8、纯虚函数与虚函数有哪些区别

在 C++ 中，虚函数和纯虚函数都是实现多态的关键机制，但它们之间存在一些基本的区别，这些区别主要涉及到它们的定义、用途和对派生类的影响。

• 虚函数（Virtual Function）
  • 定义：虚函数在基类中用 virtual 关键字声明，并可以在派生类中重写。虚函数可以有自己的实现。
  • 用途：虚函数允许派生类根据需要重写基类中的方法，但不强制要求派生类提供一个新的实现。
  • 多态实现：如果通过基类指针或引用调用虚函数，则会根据对象的实际类型来调用相应的函数版本，这是“动态绑定”或“晚绑定”的一个典型例子。
  • 示例：

    class Base {
    public:
        virtual void display() {
            cout << "Display of Base" << endl;
        }
    };
    
    class Derived : public Base {
    public:
        void display() override {
            cout << "Display of Derived" << endl;
        }
    };
    

• 纯虚函数（Pure Virtual Function）
  • 定义：纯虚函数在基类中用 virtual 关键字声明，并在声明的末尾使用 = 0 来指明这是一个纯虚函数。纯虚函数通常不提供实现。
  • 用途：纯虚函数的主要目的是定义一个接口，强制要求派生类必须提供该函数的具体实现。这样的类称为抽象类，不能被实例化。
  • 多态实现：纯虚函数保证了派生类必须重写此函数，确保了基类指针或引用调用时能够正确地执行到派生类的实现。
  • 示例：

    class AbstractBase {
    public:
        virtual void display() = 0;  // 纯虚函数
    };
    
    class ConcreteDerived : public AbstractBase {
    public:
        void display() override {
            cout << "Display of ConcreteDerived" << endl;
        }
    };
    

• 主要区别
  • 强制实现：虚函数允许派生类选择是否重写；而纯虚函数则强制派生类必须提供一个实现。
  • 实例化能力：包含纯虚函数的类（抽象类）不能被实例化，这意味着你不能创建这种类的对象。虚函数所在的类可以被实例化。
  • 设计意图：虚函数适用于那些已有默认行为，但允许派生类根据需要进行改变的情况；纯虚函数则用于设计接口，当基类的行为无法确定或不应该由基类定义时使用。

9、虚函数是怎么实现的？虚函数表存在哪个地方？

C++ 中虚函数的实现机制是通过一个特别的表结构——虚函数表（Virtual Table, 简称 VTable）来实现的。这是一个在编译时期构建的表，用于支持运行时的动态方法调用，即我们所说的动态绑定。下面是虚函数和虚函数表的实现细节以及它们的存放位置。

• 虚函数表的实现
  • 虚函数表（VTable）：
    • 每个含有虚函数的类都会有一个对应的虚函数表。这个表是一个存储函数指针的数组，每个指针指向对应的虚函数的实现。
    • 当类中声明了虚函数时，编译器会在类的每个对象中添加一个隐藏的指针，称为虚指针（vptr），指向这个类的虚函数表。
  • 虚指针（vptr）
    • 虚指针是对象内存布局中的第一个成员，指向一个静态的虚函数表。
    • 当通过基类指针调用虚函数时，运行时通过虚指针访问虚函数表，根据偏移量找到对应的虚函数执行。
  • 构造和析构：
    • 构造函数和析构函数中有特殊的代码，用来设置对象的虚指针指向正确的虚函数表。
    • 如果存在继承关系，派生类对象的虚指针会在构造期间从指向基类的虚函数表变为指向派生类的虚函数表。
• 虚函数表的位置
  • 虚函数表通常存在于程序的只读数据段（.rodata section），这是一个在程序运行时不会被修改的内存区域。每个类有一个单独的虚函数表：
    • 内存共享：由于虚函数表是静态的，同一个类的所有对象共享同一虚函数表，这节省了内存。
    • 程序启动时初始化：虚函数表在程序启动时就已经初始化好了，确保了调用的正确性。
• 示例

  #include <iostream>
  using namespace std;
  
  class Base {
  public:
      virtual void func() { cout << "Base func" << endl; }
      virtual void func2() { cout << "Base func2" << endl; }
  };
  
  class Derived : public Base {
  public:
      void func() override { cout << "Derived func" << endl; }
      void func2() override { cout << "Derived func2" << endl; }
  };
  
  int main() {
      Base* b = new Derived();
      b->func();  // Calls Derived::func()
      b->func2(); // Calls Derived::func2()
      return 0;
  }
  

  • 在这个示例中：
    • Base 类有一个虚函数表，包含 func 和 func2。
    • Derived 类有自己的虚函数表，也包含 func 和 func2，但这些函数指向 Derived 中的重写方法。
    • 每个 Derived 类的对象会有一个指向 Derived 虚函数表的虚指针。

10、怎么访问类中私有变量，友元是单向的还是双向的？友元可以继承吗？

在 C++ 中，私有成员（包括变量和函数）通常是不能直接被类外的代码访问的，这是封装的一个重要特性。然而，C++ 提供了几种方法来允许特定的外部函数或类访问类的私有成员，主要是通过友元（friend）关系和访问器（getter）方法。

• 访问私有变量的方法
  • ①、访问器（Getter）和修改器（Setter）：
    • 类可以提供公共的访问器和修改器来允许对私有变量的有限访问和修改，这是最常用的方法。
    • 示例

      class MyClass {
      private:
          int value;
      public:
          int getValue() const { return value; }
          void setValue(int v) { value = v; }
      };
      

  • ②、友元函数和友元类：
    • 友元函数或友元类可以被声明为类的“友元”，这使得它们可以访问类的所有私有和保护成员。
    • 友元声明仅需要在类定义中明确指定。
    • 示例：

    class MyClass {
    private:
        int value;
    public:
        friend void friendFunction(MyClass &obj);
    };
    void friendFunction(MyClass &obj) {
        // 可以访问 MyClass 的私有成员
        cout << obj.value;
    }
    

• 友元的单向性和继承性
  • 单向性：
    • 友元关系是单向的，而不是双向的。如果类 A 声明类 B 为友元，类 B 可以访问 A 的私有成员，但类 A 不能访问类 B 的私有成员，除非 B 也声明 A 为友元。
    • 友元关系不是相互的，必须显式声明。
  • 继承性：
    • 友元关系不可继承。如果类 B 是类 A 的友元，B 的派生类 C 并不自动成为 A 的友元。C 必须单独被声明为 A 的友元才能访问 A 的私有成员。
    • 这意味着每个新类都需要明确声明其友元关系，即使这些类是现有友元类的派生类。

11、你怎么理解引用与指针，为什么有了指针还需要引用？

• 引用（Reference）
  • 引用在 C++ 中作为一个变量的别名存在。它们必须在声明时被初始化，并且一旦绑定到一个对象，就不能再绑定到另一个对象。
  • 不可变性：
    • 引用在初始化后不能改变绑定，它们始终指向第一次被赋予的对象。
  • 使用方式：
    • 引用的使用更接近于普通变量，没有特殊的语法（如解引用操作）。
    • 引用可以用来定义函数的参数和返回值，使得函数调用和返回更加自然和高效。
  • 安全性：
    • 用比指针更安全，因为引用保证了引用的对象必须存在（除非程序本身存在未定义行为，如引用未初始化的变量）。
• 指针（Pointer）
  • 指针是包含内存地址的变量，可以指向一个对象，也可以指向内存中的任意位置。指针在运行时可以改变所指向的对象。
    • 灵活性：
      • 指针可以重新指向不同的对象。
      • 指针可以是 nullptr，表示它不指向任何对象。
    • 使用复杂度：
      • 指针需要使用特殊的语法（* 用于解引用，-> 用于访问成员）。
      • 指针的管理（包括内存管理）比引用复杂，容易出错（如野指针和内存泄漏问题）。
• 为什么需要引用？
  • 尽管指针提供了强大的功能和灵活性，引用的引入解决了某些特定场景下的需求：
    • 语义清晰：
      • 引用提供了一种更加严格的方式来表达“非空的别名”这一概念，适用于不需要重新赋值的场景。
      • 引用使得代码更易于理解和维护，尤其是在函数参数和返回值的传递中。
    • 操作简便：
      • 使用引用可以避免编写解引用代码，使得代码看起来更像是操作普通变量。
      • 在处理数组和动态数据结构时，引用可以简化代码，提高效率。
    • 支持运算符重载和复制构造：
      • 在 C++ 中，运算符重载和复制构造函数通常使用引用来实现，因为这些场景下需要对象存在且不可为空。

12、谈一下你对操作系统的理解，为什么有操作系统

操作系统（OS）是计算机系统中最基础的软件，它管理计算机硬件资源，提供软件运行时环境，并为用户和应用程序提供必要的接口。操作系统的核心功能是作为用户程序和计算机硬件之间的中介，确保计算机的有效、安全和高效运行。

• 操作系统的主要职责包括：
  • 资源管理：操作系统负责管理计算机的所有硬件资源，包括处理器、内存、硬盘和输入输出设备等。操作系统通过资源调度策略来有效地分配这些资源，确保多个应用程序和用户可以高效、公平地共享系统资源。
  • 提供用户界面：操作系统通过提供命令行或图形用户界面（GUI）使用户能够与计算机交互。这些界面简化了用户操作，使非专业用户也能容易地使用计算机系统。
  • 执行程序管理：操作系统负责程序的加载、执行、暂停和终止。它通过创建和管理进程或线程，实现了多任务和并发执行，提高了系统的效率和响应速度。
  • 文件管理：操作系统提供了文件的创建、删除、存储和访问等功能。它通过文件系统组织数据，保证数据的安全性和可靠性，并使得用户和程序能够方便地存取文件。
  • 设备驱动：操作系统通过设备驱动程序来控制硬件设备。每种设备都需要相应的驱动程序，使操作系统能够统一管理和使用这些硬件。
  • 系统安全与稳定性：操作系统负责系统的安全策略，防止未授权的访问和数据损坏。同时，操作系统还需要具备错误检测和恢复功能，以保证系统的稳定运行。
• 为什么需要操作系统？
  • 抽象：操作系统为复杂的硬件提供了一个简单的抽象界面。程序员可以不必关心硬件细节，例如如何读写磁盘扇区或发送网络数据包。
  • 便利性：操作系统通过提供用户友好的界面和功能丰富的系统调用，使得使用计算机更加便捷。
  • 效率：操作系统能够优化资源的使用，如通过多任务处理提高CPU利用率，或通过内存管理提升内存使用效率。
  • 资源共享：支持多用户或多任务环境中资源的共享和保护，确保系统的公平性和安全性。
  • 扩展性和开放性：支持新硬件和新技术的集成，允许系统随着技术的发展而扩展。

13、什么时候会进行进程调度，如何实现的进程调度

• 进程调度通常在以下几种情况下发生：
  • 多任务切换：当当前执行的进程的时间片用完，操作系统需要挑选另一个进程继续执行。
  • I/O 请求或完成：
    • 当进程进行 I/O 操作时，通常会被阻塞（等待 I/O 完成），此时调度器会挑选另一个进程执行。
    • 当 I/O 操作完成，等待 I/O 的进程可能会变为就绪状态，调度器可能会决定切换到这个进程。
  • 创建或终止进程：
    • 新创建的进程加入就绪队列，可能会被调度。
    • 当进程终止时，调度器必须选择另一个进程运行。
  • 从等待状态变为就绪状态：当进程等待的事件发生（例如收到信号），使得进程从等待状态转为就绪状态，调度器可能会介入进行调度。
  • 优先级变更：当进程的优先级被动态调整（例如，优先级继承或反馈机制），调度器可能根据新的优先级进行重新调度。

14、如何实现进程调度？

• 进程调度的实现涉及调度算法和调度机制。调度算法决定了哪个进程获得CPU，而调度机制则负责实现算法的决策。
  • 调度算法
    • 先来先服务（FCFS, First-Come, First-Served）：最简单的调度算法，按照进程到达就绪队列的顺序进行调度。
    • 短作业优先（SJF, Shortest Job First）：总是选择预计运行时间最短的进程进行调度。它的变体是最短剩余时间优先（SRTF），它是抢占式的。
    • 轮转调度（Round Robin, RR）：每个进程被分配一个固定时间的时间片。如果时间片用完，即使进程未完成，调度器也会切换到下一个进程。
    • 优先级调度：根据进程的优先级决定调度。优先级高的进程先被调度。在抢占式优先级调度中，更高优先级的进程随时可以抢占低优先级进程的执行。
    • 多级队列调度：将进程根据类型分入不同的就绪队列，每个队列可以有自己的调度算法。例如，前台交互进程和后台批处理进程可能使用不同的调度策略。
  • 调度机制
    • 上下文切换：当调度器选择另一个进程运行时，系统需要保存当前进程的状态（上下文），并加载新选定进程的上下文。
    • 中断和陷阱：系统调用或硬件中断可以触发调度器介入，进行进程切换。
    • 调度器激活：在上述触发事件发生时，调度器被激活，重新评估并选择最适合的进程执行。

二、奥比中光

1、volatile 关键字的作用是什么？

在 C 和 C++ 中，volatile 关键字是一个类型修饰符，用于告诉编译器不应对标记为 volatile 的变量进行优化，因为这些变量的值可能会在程序的控制之外发生变化。使用 volatile 声明的目的是确保代码的行为在存在某些特定类型的变量变化时保持正确和预期的。

• 主要用途和效果包括：
  • 硬件访问：当程序需要直接与硬件交互时，硬件的寄存器值可能会独立于任何程序控制的因素而改变。例如，硬件状态寄存器的值可能会因为硬件事件（如中断）而变化。
  • 操作系统内核：在开发操作系统内核时，volatile 可用于访问由多个任务或系统外部事件修改的内存位置。
  • 中断服务例程：在中断服务例程中，变量可能由中断引起的代码所修改，主线程需要访问这些变量以获取最新值。
  • 多线程应用：在多线程环境下，一个线程可能修改另一个线程需要访问的变量。虽然 volatile 并不提供线程同步（不是线程安全的），它确保变量的读写操作不会被编译器优化掉，从而保证每次访问都是直接从内存中进行。
• 示例说明

  volatile int status;
  
  void interrupt_handler() {
      status = 1; // 设置状态
  }
  
  int main() {
      while (status == 0) {
          // 等待中断发生
      }
      // 处理中断后的动作
  }
  

  • 在这个例子中，如果 status 变量没有被声明为 volatile，编译器可能会认为 status 在循环中不会改变，并可能优化掉对 status 的重复检查，导致循环变成一个无限循环。声明为 volatile 确保每次循环时都会重新从内存地址中读取 status 的值。
• 关键点
  • 非同步机制：volatile 关键字不能替代多线程程序中的锁（如互斥锁）或其他同步机制（如条件变量）。它只是告诉编译器不要优化从该变量的读取和写入，保证程序可以看到外部对变量的修改。
  • 编译器行为：volatile 修饰的变量每次用到时都直接从内存读取，不会被缓存在寄存器中，这确保了程序对外部变化的即时响应。

2、动态分配内存函数形参应该传递什么？

在 C++ 中，如果需要在函数中动态分配内存，并希望这块内存能在函数调用后仍然存在（即函数外部也能访问这块内存），通常有两种主要的传递方式：通过指针的指针（pointer to pointer）和通过引用指针（reference to pointer）。这两种方式都允许在函数内部修改传入的指针，从而使得外部调用者能够访问在函数内部分配的内存。

• 通过指针的指针
  • 这种方式涉及到传递指针变量的地址给函数。这样，函数就能修改指针变量本身，以指向新分配的内存。
  • 示例代码：

    void allocateMemory(int** ptr) {
        *ptr = new int[10]; // 分配内存
    }
    
    int main() {
        int* array = nullptr; // 初始化指针
        allocateMemory(&array); // 分配内存
        // 使用 array
        delete[] array; // 释放内存
        return 0;
    }
    

    • 在这个例子中，allocateMemory 函数接收一个指向指针的指针，因此能够修改 main 函数中的 array 指针使其指向新分配的内存。
• 通过引用指针
  • 通过引用传递指针可以简化语法，避免在调用函数时使用地址运算符。
  • 示例代码

    void allocateMemory(int*& ptr) {
        ptr = new int[10]; // 分配内存
    }
    
    int main() {
        int* array = nullptr; // 初始化指针
        allocateMemory(array); // 分配内存
        // 使用 array
        delete[] array; // 释放内存
        return 0;
    }
    

    • 在这个例子中，allocateMemory 函数接收一个引用到指针的参数，允许直接修改外部的指针。这种方法更加直观和易于管理。
• 选择哪种方式？
  • 指针的指针：这种方法在 C 风格的代码中更常见，尤其是在涉及到接口或与 C 语言库的交互时。
  • 引用指针：这是 C++ 推荐的方式，因为它更简洁，减少了代码中错误的机会，尤其是在涉及到指针操作时。

3、进程同步方法？死锁原因？

进程同步的目的是为了确保多个进程可以顺利、有序地共享资源或数据。这是操作系统设计中的核心部分，关系到系统的稳定性和效率。

• 以下是一些常见的进程同步方法：
  • 互斥锁（Mutex）:
    • 互斥锁确保同一时间只有一个进程可以访问共享资源。当一个进程访问某资源时，它会锁定这个资源，其他进程必须等待直到资源被解锁。
  • 信号量（Semaphore）:
    • 信号量是一个计数器，用于控制对共享资源的访问。信号量可以允许多个进程同时访问相同的资源，其数量由信号量的初始值决定。
  • 条件变量（Condition Variables）:
    • 条件变量用于线程之间的同步，允许某些线程在特定条件不满足时挂起，直到其他线程改变条件并通知它们。
  • 消息传递（Message Passing）:
    • 进程通过发送和接收消息来进行同步。这种方法不需要共享内存，适用于分布式系统。
  • 事件（Events）:
    • 事件通知机制使得一个进程可以等待特定事件的发生，从而进行同步。
  • 管道和文件:
    • 管道是一种半双工的通信方式，数据只能单向流动，可用于进程间的数据传输和同步。
    • 文件也可以作为共享资源，用于进程间的同步。
• 死锁原因
  • 死锁是多个进程在执行过程中因争夺资源而造成的一种僵局，每个进程都在等待其他进程释放资源。死锁的发生通常有以下四个必要条件：
    • 互斥条件: 资源不能被多个进程共享，只能由一个进程使用。
    • 占有并等待: 一个进程至少持有一个资源，并等待获取额外的资源，这些资源被其他已经阻塞的进程占有。
    • 不可抢占: 资源不能被强制从一个进程中抢占，只能由持有它的进程显式释放。
    • 循环等待: 发生死锁时，必须有一个进程—资源的循环等待链，即进程集合{P1, P2, …, Pn}中的 P1 等待 P2 持有的资源，P2 等待 P3 持有的资源，依此类推，Pn 等待 P1 持有的资源。
• 预防和解决死锁的方法
  • 预防死锁:
    • 破坏上述四个条件中的一个或多个。
    • 例如，采用一次性分配所有资源的策略，或允许资源的抢占。
  • 避免死锁:
    • 动态分析资源分配和进程状态，避免进入不安全状态。
    • 使用银行家算法等算法来预防死锁。
  • 检测死锁:
    • 定期检查资源分配图，寻找循环等待的存在。
  • 死锁恢复:
    • 进程终止或资源抢占。选择牺牲一些进程来解决死锁，或强制释放某些资源。

4、什么情况会导致内存泄漏？

内存泄漏发生在程序中已分配的内存未能正确释放，导致随着程序运行时间的增长，越来越多的内存继续被占用，最终可能导致程序或系统性能降低甚至崩溃。内存泄漏是一种常见的资源管理错误，特别是在使用手动内存管理的编程语言中，如 C 和 C++。以下是一些常见情况，这些情况可能会导致内存泄漏：

• 未释放动态分配的内存
  • 在使用动态内存分配函数（如 C 中的 malloc, calloc, realloc 和 C++ 中的 new）后，如果没有相应地调用释放函数（如 C 中的 free 和 C++ 中的 delete 或 delete[]），分配的内存将不会返回给内存池。
  • 示例

    int* allocateMemory() {
        int* ptr = new int[100]; // 动态分配内存
        return ptr; // 返回指针
    }
    // 如果在调用 allocateMemory 后没有使用 delete[] 来释放内存，将会导致泄漏。
    

• 数据结构错误
  • 错误的数据结构设计或使用错误，如链表、树等复杂数据结构在删除节点时没有正确释放节点内存。
  • 示例

    struct Node {
        int value;
        Node* next;
    };
    
    void deleteList(Node* head) {
        while (head) {
            Node* temp = head->next;
            delete head; // 假设此处没有正确设置 head = temp;
            head = temp; // 如果遗漏这行，会导致部分节点内存未被释放
        }
    }
    

• 避免和检测内存泄漏
  • 使用智能指针：在 C++ 中使用 std::unique_ptr, std::shared_ptr 等智能指针自动管理内存。

5、变量在内存中的存储方式？

变量在内存中的存储方式是理解编程和内存管理的关键部分。在现代计算机架构中，变量的存储通常涉及几个关键的内存区域：栈（Stack）、堆（Heap）、全局/静态存储区（Global/Static Storage）和代码区（Code Segment）。下面详细介绍每个区域以及变量在这些区域中的存储方式。

• 栈（Stack）
  • 栈是一种遵循后进先出（LIFO）原则的内存结构，主要用于存储局部变量和函数调用的管理数据（如返回地址和局部变量）。每当一个函数被调用时，它的返回地址和参数被推送到栈上。该函数的局部变量也在栈上分配内存。
  • 特点：分配和回收自动、速度快。
  • 用途：存储函数参数、返回数据和局部变量。
  • 限制：空间有限，适用于存储生命周期短且大小确定的数据。
• 堆（Heap）
  • 堆是用于动态内存分配的区域，由程序在运行时显式管理（在 C/C++ 中使用 malloc/new 和 free/delete）。与栈不同，堆上的内存分配和释放是由程序员控制的，不会自动管理。
  • 特点：灵活，可以动态分配任意大小的内存块。
  • 用途：存储生命周期不确定或需要在多个函数间共享的数据。
  • 限制：管理复杂，易出错（如内存泄漏、碎片化）。
• 全局/静态存储区（Global/Static Storage）
  • 这部分内存用于存储全局变量、静态变量和常量。这些变量的生命周期贯穿整个程序运行期，从程序开始执行时初始化，到程序结束时才被销毁。
  • 特点：初始化一次，直到程序结束。
  • 用途：存储需要在函数调用之间保持状态的数据或控制程序配置和行为的参数。
• 代码区（Code Segment）
  • 代码区是存储程序执行代码的内存区域。这部分内存通常是只读的，用来存放编译后的程序代码。
  • 特点：只读，尝试修改通常会导致程序崩溃。
  • 用途：存储程序的实际执行指令。

6、谈一谈结构体对齐

在 C 和 C++ 中，结构体对齐是指在内存中排列结构体成员的方式，以符合特定平台的内存访问要求。这主要涉及两个方面：对齐边界（alignment boundary）和填充字节（padding）。正确的结构体对齐可以优化内存访问速度，防止在某些硬件上可能出现的性能下降或错误。

• 对齐边界
  • 结构体对齐的基本规则是，结构体的每个成员应该从其自然对齐边界开始放置。自然对齐边界通常是该数据类型大小的最小公倍数。例如：
    • char 类型通常从任何地址开始都可以。
    • short 类型（假设为 2 字节）的变量地址应该是 2 的倍数。
    • int 类型（假设为 4 字节）的变量地址应该是 4 的倍数。
    • double 类型（假设为 8 字节）的变量地址应该是 8 的倍数。
• 填充字节
  • 为了满足对齐要求，编译器可能会在结构体成员之间插入额外的未使用空间（填充字节）。这样做是为了确保每个成员都在其对齐边界上开始，从而提高访问速度。
  • 示例

    struct Example {
        char a;    // 占用 1 字节
        int b;     // 占用 4 字节
        char c;    // 占用 1 字节
    };
    

    • 对于大多数编译器和平台，该结构体的内存布局可能如下：
      • char a 占用第一个字节。
      • 接下来是 3 字节的填充，以确保 int b 从 4 字节边界开始。
      • int b 占用接下来的 4 字节。
      • char c 占用紧跟在 int b 后面的字节。
      • 可能还会有更多填充字节，以确保整个结构体的大小是最大成员大小（4 字节）的倍数。
• 结构体总大小
  • 结构体的总大小不仅是内部成员大小的简单总和，还包括必要的填充。此外，整个结构体的对齐通常是其最大成员的对齐。
• 控制对齐
  • 在 C 和 C++ 中，可以使用特定的编译器指令来控制结构体的对齐方式。例如，GCC 提供了 __attribute__((aligned(n)))，而 Microsoft Visual C++ 提供了 #pragma pack(n)，这些可以用来指定一个更小的或更大的对齐边界。

三、芯动科技

1、Arm 汇编中 bl 的意思

在 ARM 汇编语言中，BL 指令是一个非常重要的指令，它的全称是 “Branch with Link”。BL 指令用于函数调用，在将控制权转移给函数（即分支到一个新地址去执行代码）的同时，保存返回地址。这样，被调用的函数完成执行后，可以通过这个保存的地址返回到原来的程序中继续执行。

• 工作原理
  • 当执行 BL 指令时，ARM 处理器会做两件事：
    • 保存返回地址：将当前指令的下一条指令的地址（即 BL 指令之后的地址）保存到链接寄存器（Link Register，LR），通常是 R14 寄存器。这是为了在函数执行完毕后能够知道从哪里返回。
    • 分支到目标地址：将程序计数器（Program Counter，PC）设置为 BL 指令指定的目标地址，从而跳转到该地址开始执行代码。这个目标地址通常是函数的起始地址。
• 示例
  • 假设有以下 ARM 汇编代码片段：

    _main:
        BL _function  ; 调用名为 function 的函数
        ; 返回点，执行其他指令
    _function:
        ; 执行一些操作
        BX LR         ; 返回到调用点
    

    • 在这个例子中，BL _function 指令会：
      • 将 _main 中 BL _function 指令后面的那条指令的地址存入 LR。
      • 跳转到 _function 标签所在的地址开始执行函数代码。
      • 函数执行完毕后，通过 BX LR 指令跳回到 LR 寄存器保存的地址继续执行。
• 用途
  • BL 指令通常用于：
    • 函数调用：在任何需要执行子程序（函数）的地方。
    • 生成可重入代码：由于 BL 指令保存返回地址，它允许函数被多次调用并返回到正确的位置，支持递归调用等复杂控制流。

2、static 修饰的C语言变量存放在哪里，有什么作用

在 C 语言中，static 关键字是一个非常有用的修饰符，可用于变量和函数。它影响变量或函数的存储持续性、作用域和初始化时间。以下是 static 修饰符对变量的影响和它们存放的位置：

• 存放位置
  • static 修饰的变量通常存放在程序的数据段中，特别是在一个称为静态存储区的部分。这个区域是专门用来存储生命周期贯穿整个程序运行期的数据，包括：
    • 全局变量（无论是否被 static 修饰）
    • 静态变量（包括静态局部变量和静态全局变量）
• 作用
  • 生命周期：static 变量的生命周期为整个程序执行期间。一旦被初始化，它们就会存在，直到程序终止。
  • 作用域：
    • 当 static 用于局部变量时，它改变了该变量的作用域。这意味着变量虽然在函数内部定义，但它不会在函数调用结束时销毁，而是保持其值直到下次函数调用。
    • 当 static 用于全局变量或函数时，它将变量或函数的作用域限制在声明它的文件内，即使在其他文件中声明了外部引用（通过 extern 关键字），也无法访问或链接到这些 static 全局变量或函数。
  • 初始化：static 变量（无论是全局还是局部）都在程序启动时（在 main() 函数执行前）初始化为零（除非显式初始化为其他值）。这一点不同于非静态局部变量，非静态局部变量在每次进入定义它的代码块时都会重新初始化。
• 示例

  #include <stdio.h>
  
  void function() {
      static int count = 0; // 静态局部变量
      count++;
      printf("count = %d\n", count);
  }
  
  int main() {
      for (int i = 0; i < 5; i++) {
          function(); // 每次调用function()，count 的值都会增加
      }
      return 0;
  }
  

  • 在这个示例中，函数 function 中的静态局部变量 count 在第一次调用 function 时被初始化为 0，并在每次函数调用时保持其值。输出将显示 count 的值从 1 递增到 5，即使变量 count 是在函数内部定义的，它的值也在函数调用之间持续存在。

3、C语言变量有几种储存方式

在 C 语言中，变量的存储方式主要由其声明中的存储类别说明符决定，这些存储类别说明符定义了变量的作用域（变量可以被访问的代码区域）、链接属性（变量是否可以被其他文件或模块访问）以及生命周期（变量存在的时间长度）。C 语言中主要有四种存储类别：

• 自动存储（Automatic）

  • 关键字：auto（虽然很少显式使用，因为这是局部变量的默认存储类别）
  • 作用域：局部作用域，只在定义它们的函数或代码块内可见。
  • 生命周期：仅在控制流位于声明变量的代码块内时存在。每次进入该块时创建，离开时销毁。
  • 示例：

    void function() {
        int local_var;  // 默认为 auto 类型
    }
    

• 寄存器存储（Register）

  • 关键字：register
  • 作用域：局部作用域。
  • 生命周期：与自动存储变量相同。
  • 用途：建议编译器尽可能将变量存储在 CPU 寄存器中，而非 RAM，以加速变量的访问和修改。编译器可以忽略这个建议。
  • 示例：

    void function() {
        register int fast_var;
    }
    

• 静态存储（Static）

  • 关键字：static
  • 作用域：
    • 如果用于局部变量，该变量具有局部作用域，但不会在函数调用结束时被销毁，而是持续存在直到程序结束。
    • 如果用于全局变量，限制该变量的作用域仅在定义它的文件内。
  • 示例

    void function() {
        static int persistent_var = 0;
        persistent_var++;
    }
    
    static int file_scope_var;  // 只在本文件内可见
    

• 外部存储（External or Global）

  • 关键字：extern
  • 作用域：全局作用域。
  • 生命周期：整个程序执行期间。
  • 用途：用于在一个文件中声明一个变量，而定义和初始化则在另一个文件中进行。这允许不同的文件共享变量。
  • 示例：

    // 在 file1.c 中
    int global_var = 10;
    
    // 在 file2.c 中
    extern int global_var;
    

4、变量未初始化值是多少

在 C 语言中，未初始化变量的值是不确定的，这取决于变量的类型和存储位置。

• 自动（局部非静态）变量
  • 自动变量（即那些定义在函数内部且未被 static 关键字修饰的变量）如果未初始化，它们的初始值是未定义的。这意味着它们的内容是随机的，取决于内存中该位置之前的残留数据。访问这些未初始化的变量的值是危险的，因为这可能导致不可预测的程序行为。
  • 示例

    int foo() {
        int x;  // 未初始化的局部变量
        printf("%d\n", x);  // 输出结果未定义，可能是任何值
    }
    

• 静态变量（包括全局变量）
  • 静态变量和全局变量，无论是否在函数内定义，如果未初始化，它们会自动被初始化为零。这包括全局静态变量、局部静态变量和普通的全局变量。这种行为由 C 语言的标准规定，目的是为了保证变量在使用前有一个确定的值。
  • 示例

    int global_var;  // 未初始化的全局变量，默认初始化为 0
    static int static_var;  // 未初始化的静态变量，同样默认初始化为 0
    
    int foo() {
        static int local_static_var;  // 未初始化的局部静态变量，也会被初始化为 0
        printf("%d %d %d\n", global_var, static_var, local_static_var);  // 输出 0 0 0
    }
    

• 堆内存
  • 通过 malloc 或相关函数分配的内存块，如果未手动初始化，其内容同样是未定义的。这些内存区域通常包含任意的数据（通常是垃圾数据），除非使用 calloc（它会初始化内存为零）或手动将数据写入分配的内存。
  • 示例

    int* p = (int*)malloc(sizeof(int));  // 分配内存但未初始化
    printf("%d\n", *p);  // 输出结果未定义
    free(p);
    
    int* q = (int*)calloc(1, sizeof(int));  // 分配内存并初始化为 0
    printf("%d\n", *q);  // 输出 0
    free(q);
    

5、什么是野指针

野指针是指向已释放或无效内存的指针。这类指针的存在可能导致不可预测的程序行为，包括数据损坏、程序崩溃和安全漏洞。

• 野指针通常由以下几种情况产生：
  • 释放后未置空：
    • 当内存被释放后，如通过 free() 或 delete，指向该内存的指针仍然保留着原来的地址。这种指针称为野指针。由于原内存可能被操作系统重新分配或用于其他用途，通过野指针进行的任何操作都是未定义的，并且可能是危险的。
    • 示例

      int* ptr = (int*)malloc(sizeof(int));
      *ptr = 10;
      free(ptr);
      // 此时 ptr 是野指针
      *ptr = 20;  // 未定义行为
      

  • 指针操作越界：
    • 如果指针超出了其原本指定的数据结构的边界，它可能变成野指针，指向随机的内存位置。

      int array[5] = {1, 2, 3, 4, 5};
      int* ptr = &array[4];
      ptr++;  // ptr 现在指向 array 的边界之外
      

  • 栈内存返回：
    • 函数内部创建的局部变量存储在栈上，当函数返回时，局部变量的存储空间将被回收。如果有指针指向这些局部变量，一旦函数退出，这些指针也会变成野指针。

      int* func() {
          int local = 10;
          return &local;  // 返回指向局部变量的指针
      }
      int* ptr = func();  // ptr 是野指针
      

• 处理野指针
  • 为了避免野指针带来的问题，可以采用以下策略：
    • 立即置空：在释放指针后，立即将指针设置为 NULL 或 nullptr（在 C++11 及以后）。这样做可以防止未定义行为的发生，因为对 NULL 指针的解引用通常会导致程序立即崩溃，而不是继续运行并可能导致更难追踪的错误。

      int* ptr = (int*)malloc(sizeof(int));
      free(ptr);
      ptr = NULL;  // 将 ptr 置为 NULL
      

  • 使用智能指针：在 C++ 中，可以使用智能指针如 std::unique_ptr 和 std::shared_ptr 来自动管理内存。智能指针在析构时会自动释放它们所管理的资源，并将内部的裸指针设为 nullptr，从而避免野指针问题。

    #include <memory>
    std::unique_ptr<int> ptr(new int(10));
    ptr.reset();  // 自动释放内存并将内部指针设为 nullptr
    

6、外设和处理器交互的方式

外设（如键盘、鼠标、打印机、存储设备、网络接口等）与处理器的交互主要通过以下几种方式进行：

• 端口映射 I/O（Port-Mapped I/O, PMIO）
  • 概念：在这种方式中，外设被分配一组特定的I/O端口号。处理器通过专门的I/O指令（如 IN 和 OUT 指令在 x86 架构上）访问这些端口来读写外设。
  • 特点：I/O 端口空间通常比内存地址空间小得多，处理器使用特定的指令进行访问，这可以简化编程模型和硬件设计。
• 内存映射 I/O（Memory-Mapped I/O, MMIO）
  • 概念：在内存映射I/O中，外设控制寄存器被映射到主内存地址空间的一部分。处理器可以使用普通的内存访问指令（如 MOV）来访问这些控制寄存器，就像访问普通内存一样。
  • 特点：由于使用标准的内存访问指令，编程通常更直观和灵活。这也允许外设和处理器之间更高效的数据传输，尤其是在需要传输大量数据时。
• 直接内存访问（Direct Memory Access, DMA）
  • 概念：DMA 是一种允许某些硬件子系统独立于主CPU对系统内存进行读写的技术。DMA 控制器可以在不占用CPU的情况下，直接在内存和外设之间传输数据。
  • 特点：极大地提高数据传输效率，减轻CPU负担，常用于高速数据传输场景，如硬盘、声卡、网络卡等。
• 中断（Interrupts）
  • 概念：当外设需要处理器注意时（例如，数据准备好了或设备需要服务），它会发送一个中断信号到处理器。处理器会在适当的时间点响应中断，暂停当前任务，保存状态，然后执行一个特定的中断服务程序（ISR）来处理外设的需求。
  • 特点：中断驱动的通信允许处理器高效地响应多个外设的需求，而不需要在轮询每个设备状态时浪费资源。
• 轮询（Polling）
  • 概念：处理器定期检查外设的状态以确定是否需要服务，而不是等待外设发出中断。
  • 特点：在某些实时或低延迟要求的应用中，轮询可以提供稳定的响应时间，因为它不依赖于中断处理的开销。然而，这种方法可能会占用更多的CPU资源，因为处理器需要持续检查外设状态。

---

我的qq：2442391036，欢迎交流！

---