操作系统面经|进程和线程

进程和线程|进程和线程的区别

• 调度：线程是程序执⾏的基本单位；进程是拥有资源的基本单位。

• 并发性：进程内部的多个线程并发； 不同进程之间切换实现并发，各⾃占有CPU实现并⾏

• 拥有资源：线程不拥有系统资源，但单进程的多个线程可以共享属于进程的资源；进程是拥有资源的独⽴单位。

• 系统开销：线程切换时只需保存和设置少量寄存器内容、程序计数器和栈指针，因此开销很小；进程需要切换虚拟地址空间，切换内核栈和硬件上下文等，开销很大

进程和线程|为什么设计了内核态和用户态

处于安全性和稳定性考虑。

• 安全性 内核态具有最高的特权级别。1.能够执行所有的CPU指令并访问所有的内存地址；2.内核态可以直接访问硬件设备；3.某些特权指令只有在内核态才能执行，例如内存管理（如设置页表）、设备控制（如I/O端口访问）、中断处理和系统状态设置（如设置时钟）。

  而用户态具有较低的特权级别，限制了对系统资源的直接访问。这虽然增加了一些开销，防止用户程序进行不安全或非法的操作，导致系统崩溃

• 稳定性 如果用户态的程序出现错误或崩溃，只会影响该特定程序 ，而不会影响到内核或其他用户态程序。操作系统可以在用户程序出错时采取措施进行 恢复 ，例如通过进程隔离和内存保护机制来捕获和处理异常.

• 资源管理 内核态 负责管理系统的硬件资源 ，如CPU、内存、硬盘和网络设备等，负责进程调度和上下文切换。用户态程序必须通过系统调用（system call）请求内核服务。

进程和线程|如何切换内核态和用户态

• 系统调用（System Call）
  由于某些操作（如文件操作、进程控制、内存管理等）需要访问受保护的系统资源，而用户态无法直接完成这些操作，因此需要通过系统调用切换到内核态执行。主动发起的请求
• 出现异常
  用户程序在执行过程中发生的 意外情况（如除零错误、非法内存访问等），需要内核处理。发生异常时，CPU会自动切换到内核态，执行内核中的异常处理程序。 系统被动地进行处理
• 外围设备中断
  外围设备（如硬盘、网络接口、键盘等）发出中断信号时，当前 正在执行的用户态进程会被暂停，CPU切换到内核态处理中断。中断处理完成后，CPU可能会 继续执行 被暂停的用户态进程。

进程和线程|进程间通信

（进程间通信 IPC，Inter-Process Communication）

• 管道：管道是一种半双工的通信方式，数据只能单向流动

  • 无名管道（内存文件）：只能在具有亲缘关系的进程之间使用，通常为父子进程
  • 有名管道（FIFO文件）：可以在不相关的进程之间交换数据

• 共享内存：共享内存就是映射一段能被其他进程访问的内存，该段内存由一个进程创建，但是多个进程可以访问。共享内存是最快的的IPC方式，往往和信号量配合使用来实现进程间的同步和通信

• 消息队列：是有消息的链表，存放在内核中并由消息队列识别符标识。消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓存区大小受限等缺点。

  Qt 应用程序使用事件循环来处理和分发来自操作系统的事件，例如鼠标点击、按键、定时器、信号和槽等。事件循环中的事件会被存储在一个消息队列中，队列中的事件会按照先进先出的顺序进行处理。虽然 Qt 本身不直接暴露一个“消息队列”对象，但 QCoreApplication 或 QApplication 管理着一个内部的事件队列。

• 信号：用于通知进程某个事件已经发生：比如ctrl+c就是一个信号量

• 信号量：是一个计数器，用来控制多个进程对共享资源的访问

• 套接字：适用于不同机器之间进程通信，在本地也可以作为两个进程的通信方式

通信机制	描述	优点	缺点
无名管道 (Pipe)	单向通信，数据通过管道从一个进程传递到另一个进程。	简单易用，适用于父子进程间的通信。	只能用于有亲缘关系的进程间通信，数据传输速度较慢。
有命管道 (FIFO)	类似于管道，但可以用于任意进程间的通信。	支持无亲缘关系的进程间通信，使用简单。	需要创建和管理命名管道文件，数据传输速度较慢。
共享内存	多个进程共享一块内存区，实现高速通信。	通信速度快，数据存储在共享内存中，效率高。	需要同步机制来防止数据竞争，管理复杂。
消息队列	进程通过发送和接收消息来通信，消息存储在内核中。	支持随机读取消息，有优先级机制，灵活性高。	消息长度受限，内核维护消息队列，占用系统资源。
信号 (Signal)	用于通知进程某个事件的发生。	简单高效，适用于异步事件通知。	信号量有限，信息量少，适用于简单通知，不适合大数据量传输。
信号量 (Semaphore)	主要用于进程间的同步，可以实现互斥和同步。	提供了严格的同步机制，控制进程间的访问顺序。	仅用于同步，不能传递复杂信息，管理和使用较为复杂。
套接字 (Socket)	支持网络通信，可以在不同机器间通信。	功能强大，支持跨网络通信，适用于分布式系统。	通信开销较大，设置和使用较为复杂。

进程和线程|线程间同步

线程同步机制是指在多线程编程中，为了防止线程之间可能会产出的竞态条件，保证互不⼲扰，而采用的⼀种机制。

常见的线程同步机制有以下几种：

1. 互斥锁（Mutex）：互斥锁是一种基本的同步机制，用于防止多个线程同时访问某个共享资源。当一个线程获取了互斥锁，其他线程必须等待直到该锁被释放。
2. 读写锁（Read-Write Lock）：读写锁允许多个线程同时读取数据，但写入数据时需要独占访问。这可以提高性能，因为读操作通常比写操作频繁。
3. 信号量（Semaphore）：信号量是一种计数器，用来表示可用资源的数量。**线程在访问资源前需要先获取信号量，访问完成后释放信号量。**对应的变量是一个整型（sem）变量。两个原子操作的系统调用函数来控制信号量的，分别是：
   • P 操作：将 sem 减 1，相减后，如果 sem < 0，则进程/线程进入阻塞等待，否则继续，表明 P 操作可能会阻塞；
   • V 操作：将 sem 加 1，相加后，如果 sem <= 0，则表明当前有阻塞中的进程，于是会将该进程唤醒运行；如果sem > 0，则表明当前没有阻塞中的进程；
4. 条件变量（Condition Variable）：条件变量用于线程间的协调，允许一个或多个线程在某些条件成立之前挂起执行，并在条件满足时被唤醒。

进程和线程|条件变量怎么用

条件变量和锁是紧密相关的。

锁的使用场景：一个事同时只有一个人做，我抢到锁就我先进去操作，操作完毕再给下一个做

条件变量场景：

1. 首先，这件事情还是只能由一个人做，所以还是要用到锁，但线程抢到锁之后，发现还要等待一些条件满足才能做

2. 这时如果抢到的锁的线程一直循环检查这个条件，消耗高，而且每次检查完为了不让CPU一直空跑，需要sleep一下。

   sleep少，消耗高，sleep长，则有延迟，无法及时发现条件满足。抢到锁后的一直检查别的线程就无法拿到锁了

3. 引入条件变量，抢到所得线程发现条件未满足时，释放锁，使用pthread_cond_wait()挂起自己。

   这时别的线程可以获取锁进来，发现条件不满足同样挂起；

   直到条件满足，由其他地方调用pthread_cond_broadcast()来唤醒全部挂掉的线程，或者调用pthread_cond_signal唤醒指定线程。

进程和线程|线程安全

线程安全（Thread Safety）是指在多线程环境下访问共享资源时，确保代码能够正确地执行，而不会产生竞态条件（Race Condition）或导致数据不一致性的问题。

互斥锁、读写锁、使用原子操作、

进程和线程|std::thread如何创建和管理线程？

在 C++ 中，std::thread 是用于创建和管理线程的标准库类。下面是一些关于 std::thread 的基本用法和管理线程的方式。

1. 创建线程

创建线程时，需要传递一个可调用对象（如函数、lambda 表达式或函数对象）作为参数。

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建并启动线程
    std::thread t(threadFunction);

    // 主线程等待子线程完成
    t.join();
    return 0;
}

在这个例子中，std::thread t(threadFunction); 创建了一个新线程，执行 threadFunction。t.join(); 是用来等待这个线程执行完毕的。

2. 使用 Lambda 表达式

你也可以通过 lambda 表达式来创建线程：

int main() {
    std::thread t([] {
        std::cout << "Hello from lambda!" << std::endl;
    });

    t.join();  // 等待线程结束
    return 0;
}

3. 传递参数

std::thread 可以将参数传递给线程函数。参数将通过值传递，如果要通过引用传递，需要使用 std::ref。

void printMessage(const std::string& message, int count) {
    for (int i = 0; i < count; ++i) {
        std::cout << message << std::endl;
    }
}

int main() {
    std::string message = "Hello, Thread!";
    std::thread t(printMessage, std::ref(message), 5);

    t.join();
    return 0;
}

4. 线程管理

• join(): 等待线程执行结束。在调用 join() 之前，主线程会阻塞。

• detach(): 分离线程，将线程交给系统管理，主线程不再等待线程结束。

std::thread t([] {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Detached thread finished!" << std::endl;
});

t.detach();  // 分离线程，主线程不会等待此线程结束

• 检查线程是否可联结（joinable()）: 检查线程是否可以调用 join()，即线程是否处于可联结状态。

if (t.joinable()) {
    t.join();
}

5. 资源管理

线程管理需要小心，必须确保在线程对象销毁前调用 join() 或 detach()，否则会引发异常。

std::thread t(someFunction);
if (t.joinable()) {
    t.join();
}

6. 多线程并行执行

你可以创建多个线程来并行执行多个任务：

void task1() {
    std::cout << "Task 1 executing" << std::endl;
}

void task2() {
    std::cout << "Task 2 executing" << std::endl;
}

int main() {
    std::thread t1(task1);
    std::thread t2(task2);

    t1.join();
    t2.join();
    return 0;
}

以上代码创建了两个线程 t1 和 t2，它们会并行执行 task1 和 task2。

总结

• 使用 std::thread 来创建线程。
• 使用 join() 等待线程结束，或者使用 detach() 让线程独立运行。
• 使用 joinable() 检查线程是否可以联结。
• 线程的参数可以通过值或引用传递。

进程和线程|消费者生产者模型

一种多线程编程中的经典同步问题。其主要目的是在共享资源（通常是缓冲区）上协调多个生产者线程和消费者线程的操作。

• 生产者（Producer）：生产者线程的任务是生成数据并将其放入共享缓冲区。当缓冲区满时，生产者线程需要等待直到缓冲区有空间。

• 消费者（Consumer）：消费者线程的任务是从共享缓冲区中取出数据进行处理。当缓冲区为空时，消费者线程需要等待直到缓冲区中有数据。

#include <pthread.h>
#include <iostream>
#include <queue>
#include <unistd.h>

using namespace std;

// 定义一个模板类，用于实现阻塞队列
template<typename T>
class BlockQueue {
private:
    // 检查队列是否已满
    bool isFull() {
        return que.size() == _capacity;
    }

    // 检查队列是否为空
    bool isEmpty() {
        return que.empty();
    }

public:
    // 构造函数，初始化队列容量及互斥锁和条件变量
    BlockQueue(int cap = 5) :_capacity(cap) {
        pthread_mutex_init(&_mutex, NULL);  // 初始化互斥锁
        pthread_cond_init(&_full, NULL);    // 初始化条件变量，表示队列满
        pthread_cond_init(&_empty, NULL);   // 初始化条件变量，表示队列空
    }
    
    // 析构函数，销毁互斥锁和条件变量
    ~BlockQueue() {
        pthread_mutex_destroy(&_mutex);     // 销毁互斥锁
        pthread_cond_destroy(&_full);       // 销毁条件变量 _full
        pthread_cond_destroy(&_empty);      // 销毁条件变量 _empty
    }

public:
    // 生产者调用此方法向队列中添加元素
    void push(const T& data) {
        pthread_mutex_lock(&_mutex);        // 加锁，进入临界区
        while (isFull()) {                  // 如果队列已满，则生产者等待
            pthread_cond_wait(&_full, &_mutex);
        }
        que.push(data);                     // 添加元素到队列
        pthread_cond_signal(&_empty);       // 通知消费者队列非空
        pthread_mutex_unlock(&_mutex);      // 解锁，离开临界区
    }
    
    // 消费者调用此方法从队列中取出元素
    void pop(T& data) {
        pthread_mutex_lock(&_mutex);        // 加锁，进入临界区
        while (isEmpty()) {                 // 如果队列为空，则消费者等待
            pthread_cond_wait(&_empty, &_mutex);
        }
        data = que.front();                 // 取出队列头部的元素
        que.pop();                          // 弹出队列头部的元素
        pthread_cond_signal(&_full);        // 通知生产者队列非满
        pthread_mutex_unlock(&_mutex);      // 解锁，离开临界区
    }

private:
    queue<T> que;                           // 队列容器
    int _capacity;                          // 队列的容量
    pthread_mutex_t _mutex;                 // 互斥锁，用于保护临界区
    pthread_cond_t _full;                   // 条件变量，表示队列满
    pthread_cond_t _empty;                  // 条件变量，表示队列空
};