#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <stdbool.h>

// 模擬任務(wù)結(jié)構(gòu)
typedef struct {
    const char* name;
    int priority;       // 優(yōu)先級(jí)：數(shù)值越大優(yōu)先級(jí)越高
    volatile bool running;  // 任務(wù)是否運(yùn)行中
    pthread_t tid;      // 線程ID
} Task;

// 模擬內(nèi)核狀態(tài)
volatile int preempt_count = 0;          // 搶占計(jì)數(shù)
volatile bool tif_need_resched = false;  // 重調(diào)度標(biāo)志
volatile Task* current_task = NULL;      // 當(dāng)前運(yùn)行任務(wù)

// 任務(wù)列表
Task taskA = {"TaskA", 1, false, 0};  // 低優(yōu)先級(jí)任務(wù)
Task taskB = {"TaskB", 3, false, 0};  // 高優(yōu)先級(jí)任務(wù)

// 模擬內(nèi)核調(diào)度器：選擇最高優(yōu)先級(jí)的就緒任務(wù)
Task* scheduler() {
    if (taskB.running) return &taskB;
    if (taskA.running) return &taskA;
    return NULL;
}

// 模擬上下文切換
void context_switch(Task* prev, Task* next) {
    if (prev == next) return;

    printf("\n[調(diào)度器] 發(fā)生上下文切換: %s -> %s\n", 
           prev ? prev->name : "None", next->name);
    current_task = next;
}

// 模擬中斷處理程序
void interrupt_handler(int signum) {
    printf("\n[中斷處理] 收到硬盤數(shù)據(jù)讀取完成中斷!\n");
    preempt_count++;  // 進(jìn)入中斷，禁止搶占

    // 在中斷處理中喚醒高優(yōu)先級(jí)任務(wù)B
    if (!taskB.running) {
        printf("[中斷處理] 喚醒高優(yōu)先級(jí)任務(wù)B\n");
        taskB.running = true;
        tif_need_resched = true;  // 設(shè)置重調(diào)度標(biāo)志
    }

    preempt_count--;  // 離開中斷，恢復(fù)搶占計(jì)數(shù)
}

// 低優(yōu)先級(jí)任務(wù)A的執(zhí)行函數(shù)
void* taskA_func(void* arg) {
    taskA.running = true;
    current_task = &taskA;
    printf("[%s] 開始運(yùn)行 (內(nèi)核態(tài))\n", taskA.name);

    // 模擬長(zhǎng)時(shí)間運(yùn)行的內(nèi)核操作
    for (int i = 0; i < 5; i++) {
        printf("[%s] 正在執(zhí)行內(nèi)核操作... (%d/5)\n", taskA.name, i+1);
        sleep(1);  // 模擬耗時(shí)操作
    }

    taskA.running = false;
    printf("[%s] 完成內(nèi)核操作\n", taskA.name);
    return NULL;
}

// 高優(yōu)先級(jí)任務(wù)B的執(zhí)行函數(shù)
void* taskB_func(void* arg) {
    // 等待被喚醒
    while (!taskB.running) {
        usleep(100);
    }

    current_task = &taskB;
    printf("[%s] 開始運(yùn)行 (內(nèi)核態(tài))\n", taskB.name);

    // 模擬任務(wù)B的內(nèi)核操作
    for (int i = 0; i < 3; i++) {
        printf("[%s] 正在執(zhí)行內(nèi)核操作... (%d/3)\n", taskB.name, i+1);
        sleep(1);
    }

    taskB.running = false;
    printf("[%s] 完成內(nèi)核操作\n", taskB.name);
    return NULL;
}

// 模擬內(nèi)核搶占檢查（在中斷返回時(shí)調(diào)用）
void check_preemption() {
    if (tif_need_resched && preempt_count == 0) {
        printf("\n[搶占檢查] 滿足搶占條件，觸發(fā)調(diào)度!\n");
        Task* next_task = scheduler();
        if (next_task && next_task != current_task) {
            context_switch(current_task, next_task);
        }
        tif_need_resched = false;  // 清除重調(diào)度標(biāo)志
    }
}

// 模擬中斷返回過(guò)程
void interrupt_return() {
    printf("[中斷返回] 從中斷處理程序返回內(nèi)核空間\n");
    check_preemption();  // 返回時(shí)檢查是否需要搶占
}

int main() {
    // 注冊(cè)信號(hào)處理函數(shù)模擬中斷
    signal(SIGUSR1, interrupt_handler);

    // 創(chuàng)建任務(wù)線程
    pthread_create(&taskA.tid, NULL, taskA_func, NULL);
    pthread_create(&taskB.tid, NULL, taskB_func, NULL);

    // 等待任務(wù)A運(yùn)行一段時(shí)間后發(fā)送中斷
    sleep(2);
    printf("\n[主程序] 觸發(fā)硬件中斷\n");
    pthread_kill(taskA.tid, SIGUSR1);  // 向任務(wù)A發(fā)送信號(hào)模擬中斷

    // 模擬中斷返回過(guò)程（實(shí)際內(nèi)核中由硬件自動(dòng)完成）
    interrupt_return();

    // 等待所有任務(wù)完成
    pthread_join(taskA.tid, NULL);
    pthread_join(taskB.tid, NULL);

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>

// 任務(wù)結(jié)構(gòu)定義
typedef struct {
    const char* name;
    int priority;               // 優(yōu)先級(jí)(數(shù)值越大優(yōu)先級(jí)越高)
    volatile bool running;      // 任務(wù)運(yùn)行狀態(tài)
    pthread_t tid;              // 線程ID
} Task;

// 內(nèi)核狀態(tài)模擬
volatile int preempt_count = 0;          // 搶占計(jì)數(shù)器
volatile bool tif_need_resched = false;  // 重調(diào)度標(biāo)志位
volatile Task* current_task = NULL;      // 當(dāng)前運(yùn)行任務(wù)
volatile bool shared_data_busy = false;  // 共享數(shù)據(jù)鎖定標(biāo)志

// 定義兩個(gè)任務(wù)：低優(yōu)先級(jí)A和高優(yōu)先級(jí)B
Task taskA = {"TaskA", 1, false, 0};
Task taskB = {"TaskB", 3, false, 0};

// 模擬內(nèi)核調(diào)度器：選擇最高優(yōu)先級(jí)的就緒任務(wù)
Task* scheduler() {
    if (taskB.running) return &taskB;
    if (taskA.running) return &taskA;
    return NULL;
}

// 模擬上下文切換
void context_switch(Task* prev, Task* next) {
    if (prev == next) return;

    printf("\n[調(diào)度器] 發(fā)生上下文切換: %s -> %s\n",
           prev ? prev->name : "None", next->name);
    current_task = next;
}

// 模擬搶占啟用函數(shù)
void preempt_enable() {
    preempt_count--;
    printf("[preempt_enable] 搶占計(jì)數(shù)變?yōu)? %d\n", preempt_count);

    // 檢查是否滿足搶占條件
    if (preempt_count == 0 && tif_need_resched) {
        printf("[preempt_enable] 滿足搶占條件，觸發(fā)調(diào)度!\n");
        Task* next_task = scheduler();
        if (next_task && next_task != current_task) {
            context_switch(current_task, next_task);
        }
        tif_need_resched = false;  // 清除重調(diào)度標(biāo)志
    }
}

// 模擬搶占禁用函數(shù)
void preempt_disable() {
    preempt_count++;
    printf("[preempt_disable] 搶占計(jì)數(shù)變?yōu)? %d\n", preempt_count);
}

// 模擬訪問(wèn)共享數(shù)據(jù)結(jié)構(gòu)的函數(shù)
void access_shared_data() {
    printf("[%s] 準(zhǔn)備訪問(wèn)共享數(shù)據(jù)，禁止搶占\n", current_task->name);
    preempt_disable();          // 進(jìn)入不可搶占區(qū)域
    shared_data_busy = true;

    // 模擬共享數(shù)據(jù)操作
    printf("[%s] 正在操作共享數(shù)據(jù)...\n", current_task->name);
    sleep(2);  // 模擬耗時(shí)操作

    shared_data_busy = false;
    printf("[%s] 共享數(shù)據(jù)操作完成，允許搶占\n", current_task->name);
    preempt_enable();           // 離開不可搶占區(qū)域，可能觸發(fā)搶占
}

// 高優(yōu)先級(jí)任務(wù)B的執(zhí)行函數(shù)
void* taskB_func(void* arg) {
    while (1) {
        if (!taskB.running) {
            usleep(100);  // 等待被喚醒
            continue;
        }

        current_task = &taskB;
        printf("\n[%s] 開始執(zhí)行 (高優(yōu)先級(jí)任務(wù))\n", taskB.name);

        // 執(zhí)行任務(wù)B的工作
        for (int i = 0; i < 3; i++) {
            printf("[%s] 執(zhí)行核心工作... (%d/3)\n", taskB.name, i+1);
            sleep(1);
        }

        taskB.running = false;
        printf("[%s] 任務(wù)執(zhí)行完畢\n", taskB.name);
        break;
    }
    return NULL;
}

// 低優(yōu)先級(jí)任務(wù)A的執(zhí)行函數(shù)
void* taskA_func(void* arg) {
    taskA.running = true;
    current_task = &taskA;
    printf("[%s] 開始執(zhí)行 (低優(yōu)先級(jí)任務(wù))\n", taskA.name);

    // 執(zhí)行一些前期工作
    printf("[%s] 執(zhí)行前期準(zhǔn)備工作...\n", taskA.name);
    sleep(1);

    // 訪問(wèn)共享數(shù)據(jù)（不可搶占區(qū)域）
    access_shared_data();

    // 繼續(xù)執(zhí)行剩余工作
    printf("[%s] 繼續(xù)執(zhí)行剩余工作...\n", taskA.name);
    sleep(2);

    taskA.running = false;
    printf("[%s] 任務(wù)執(zhí)行完畢\n", taskA.name);
    return NULL;
}

// 模擬喚醒高優(yōu)先級(jí)任務(wù)的函數(shù)（可在中斷或其他任務(wù)中調(diào)用）
void wake_high_priority_task() {
    if (!taskB.running) {
        printf("\n[系統(tǒng)] 喚醒高優(yōu)先級(jí)任務(wù)B\n");
        taskB.running = true;
        tif_need_resched = true;  // 設(shè)置重調(diào)度標(biāo)志
        printf("[系統(tǒng)] 設(shè)置TIF_NEED_RESCHED標(biāo)志\n");
    }
}

int main() {
    // 創(chuàng)建任務(wù)線程
    pthread_create(&taskA.tid, NULL, taskA_func, NULL);
    pthread_create(&taskB.tid, NULL, taskB_func, NULL);

    // 等待任務(wù)A進(jìn)入不可搶占區(qū)域后喚醒任務(wù)B
    sleep(2);  // 確保taskA已進(jìn)入共享數(shù)據(jù)操作
    wake_high_priority_task();

    // 等待所有任務(wù)完成
    pthread_join(taskA.tid, NULL);
    pthread_join(taskB.tid, NULL);

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>

// 任務(wù)結(jié)構(gòu)定義
typedef struct {
    const char* name;
    int priority;               // 優(yōu)先級(jí)：數(shù)值越大優(yōu)先級(jí)越高
    volatile bool running;      // 任務(wù)運(yùn)行狀態(tài)
    pthread_t tid;              // 線程ID
} Task;

// 內(nèi)核狀態(tài)模擬
volatile int preempt_count = 0;          // 搶占計(jì)數(shù)器
volatile bool tif_need_resched = false;  // 重調(diào)度標(biāo)志位
volatile Task* current_task = NULL;      // 當(dāng)前運(yùn)行任務(wù)

// 定義任務(wù)：低優(yōu)先級(jí)初始化任務(wù)和高優(yōu)先級(jí)等待任務(wù)
Task init_task = {"InitTask", 1, false, 0};  // 模擬內(nèi)核模塊初始化任務(wù)
Task high_prio_task = {"HighPrioTask", 5, false, 0};  // 高優(yōu)先級(jí)任務(wù)

// 調(diào)度器：選擇最高優(yōu)先級(jí)的就緒任務(wù)
Task* scheduler() {
    if (high_prio_task.running) return &high_prio_task;
    if (init_task.running) return &init_task;
    return NULL;
}

// 模擬上下文切換
void context_switch(Task* prev, Task* next) {
    if (prev == next) return;
    printf("\n[調(diào)度器] 上下文切換: %s -> %s\n", 
           prev ? prev->name : "None", next->name);
    current_task = next;
}

// 禁止搶占（preempt_disable模擬）
void preempt_disable() {
    preempt_count++;
    printf("[內(nèi)核] 禁止搶占，preempt_count = %d\n", preempt_count);
}

// 允許搶占（preempt_enable模擬）
void preempt_enable() {
    preempt_count--;
    printf("[內(nèi)核] 允許搶占，preempt_count = %d\n", preempt_count);

    // 檢查搶占條件：計(jì)數(shù)為0且需要重調(diào)度
    if (preempt_count == 0 && tif_need_resched) {
        printf("[內(nèi)核] 滿足搶占條件，觸發(fā)調(diào)度\n");
        Task* next = scheduler();
        if (next && next != current_task) {
            context_switch(current_task, next);
        }
        tif_need_resched = false;  // 清除重調(diào)度標(biāo)志
    }
}

// 模擬內(nèi)核模塊初始化函數(shù)（需要禁止搶占的關(guān)鍵代碼）
void kernel_module_init() {
    printf("\n[InitTask] 開始內(nèi)核模塊初始化（禁止搶占以保證原子性）\n");
    preempt_disable();  // 進(jìn)入不可搶占區(qū)域

    // 模擬初始化過(guò)程（耗時(shí)操作）
    for (int i = 0; i < 3; i++) {
        printf("[InitTask] 執(zhí)行初始化步驟 %d/3\n", i+1);
        sleep(1);
    }

    printf("[InitTask] 初始化完成，恢復(fù)搶占狀態(tài)\n");
    preempt_enable();   // 離開不可搶占區(qū)域，可能觸發(fā)搶占
}

// 高優(yōu)先級(jí)任務(wù)執(zhí)行函數(shù)
void* high_prio_task_func(void* arg) {
    while (1) {
        if (!high_prio_task.running) {
            usleep(100);  // 等待被喚醒
            continue;
        }

        current_task = &high_prio_task;
        printf("\n[%s] 獲得CPU，開始執(zhí)行高優(yōu)先級(jí)任務(wù)\n", high_prio_task.name);

        // 執(zhí)行高優(yōu)先級(jí)任務(wù)工作
        for (int i = 0; i < 2; i++) {
            printf("[%s] 處理緊急任務(wù) %d/2\n", high_prio_task.name, i+1);
            sleep(1);
        }

        high_prio_task.running = false;
        printf("[%s] 高優(yōu)先級(jí)任務(wù)執(zhí)行完畢\n", high_prio_task.name);
        break;
    }
    return NULL;
}

// 初始化任務(wù)執(zhí)行函數(shù)
void* init_task_func(void* arg) {
    init_task.running = true;
    current_task = &init_task;
    printf("[%s] 啟動(dòng)內(nèi)核模塊初始化任務(wù)\n", init_task.name);

    // 執(zhí)行初始化（包含不可搶占區(qū)域）
    kernel_module_init();

    // 初始化后的后續(xù)工作
    printf("\n[%s] 繼續(xù)執(zhí)行初始化后的收尾工作\n", init_task.name);
    sleep(1);

    init_task.running = false;
    printf("[%s] 所有工作完成\n", init_task.name);
    return NULL;
}

// 喚醒高優(yōu)先級(jí)任務(wù)的函數(shù)
void wake_high_prio_task() {
    if (!high_prio_task.running) {
        printf("\n[系統(tǒng)] 高優(yōu)先級(jí)任務(wù)等待調(diào)度，設(shè)置TIF_NEED_RESCHED\n");
        high_prio_task.running = true;
        tif_need_resched = true;
    }
}

int main() {
    // 創(chuàng)建任務(wù)線程
    pthread_create(&init_task.tid, NULL, init_task_func, NULL);
    pthread_create(&high_prio_task.tid, NULL, high_prio_task_func, NULL);

    // 等待初始化任務(wù)進(jìn)入不可搶占區(qū)域后喚醒高優(yōu)先級(jí)任務(wù)
    sleep(2);  // 確保init_task已進(jìn)入禁止搶占狀態(tài)
    wake_high_prio_task();

    // 等待所有任務(wù)完成
    pthread_join(init_task.tid, NULL);
    pthread_join(high_prio_task.tid, NULL);

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>

// 任務(wù)結(jié)構(gòu)定義
typedef struct {
    const char* name;
    int priority;               // 優(yōu)先級(jí)：數(shù)值越大優(yōu)先級(jí)越高
    volatile bool running;      // 任務(wù)運(yùn)行狀態(tài)
    pthread_t tid;              // 線程ID
} Task;

// 內(nèi)核狀態(tài)模擬
volatile int preempt_count = 0;          // 搶占計(jì)數(shù)器
volatile bool tif_need_resched = false;  // 重調(diào)度標(biāo)志位
volatile Task* current_task = NULL;      // 當(dāng)前運(yùn)行任務(wù)
volatile bool resource_available = false; // 共享資源可用性

// 定義任務(wù)：等待資源的任務(wù)A和就緒任務(wù)B
Task taskA = {"TaskA", 2, false, 0};  // 會(huì)主動(dòng)調(diào)用schedule()的任務(wù)
Task taskB = {"TaskB", 2, false, 0};  // 可運(yùn)行的其他任務(wù)

// 調(diào)度器：選擇就緒的任務(wù)（此處簡(jiǎn)化為輪詢）
Task* scheduler() {
    if (taskB.running) return &taskB;
    if (taskA.running) return &taskA;
    return NULL;
}

// 模擬上下文切換
void context_switch(Task* prev, Task* next) {
    if (prev == next) return;
    printf("\n[調(diào)度器] 上下文切換: %s -> %s\n", 
           prev ? prev->name : "None", next->name);
    current_task = next;
}

// 模擬主動(dòng)調(diào)度函數(shù)（無(wú)論狀態(tài)如何都觸發(fā)調(diào)度）
void schedule() {
    printf("\n[%s] 主動(dòng)調(diào)用schedule()，讓出CPU\n", current_task->name);
    Task* next_task = scheduler();
    if (next_task && next_task != current_task) {
        context_switch(current_task, next_task);
    }
}

// 模擬資源等待函數(shù)（任務(wù)會(huì)在此處主動(dòng)調(diào)度）
void wait_for_resource() {
    printf("[%s] 嘗試獲取資源...\n", current_task->name);
    while (!resource_available) {
        // 資源未就緒，主動(dòng)讓出CPU
        schedule();
        // 調(diào)度回來(lái)后再次檢查資源
        usleep(100000); // 短暫延遲后重試
    }
    printf("[%s] 成功獲取資源！\n", current_task->name);
}

// 任務(wù)A的執(zhí)行函數(shù)（會(huì)等待資源并主動(dòng)調(diào)度）
void* taskA_func(void* arg) {
    taskA.running = true;
    current_task = &taskA;
    printf("[%s] 開始執(zhí)行，需要等待資源\n", taskA.name);

    // 等待資源（會(huì)主動(dòng)調(diào)用schedule()）
    wait_for_resource();

    // 獲得資源后執(zhí)行后續(xù)操作
    printf("[%s] 使用資源完成工作...\n", taskA.name);
    sleep(1);

    taskA.running = false;
    printf("[%s] 任務(wù)執(zhí)行完畢\n", taskA.name);
    return NULL;
}

// 任務(wù)B的執(zhí)行函數(shù)（可被調(diào)度的任務(wù)）
void* taskB_func(void* arg) {
    taskB.running = true;
    // 等待被調(diào)度
    while (current_task != &taskB) {
        usleep(100000);
    }

    printf("\n[%s] 獲得CPU，開始執(zhí)行任務(wù)\n", taskB.name);

    // 執(zhí)行任務(wù)B的工作
    for (int i = 0; i < 3; i++) {
        printf("[%s] 執(zhí)行任務(wù)步驟 %d/3\n", taskB.name, i+1);
        sleep(1);
    }

    // 任務(wù)B完成后釋放資源
    resource_available = true;
    printf("[%s] 任務(wù)完成，釋放資源\n", taskB.name);

    taskB.running = false;
    return NULL;
}

int main() {
    // 創(chuàng)建任務(wù)線程
    pthread_create(&taskA.tid, NULL, taskA_func, NULL);
    pthread_create(&taskB.tid, NULL, taskB_func, NULL);

    // 等待所有任務(wù)完成
    pthread_join(taskA.tid, NULL);
    pthread_join(taskB.tid, NULL);

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>

// 任務(wù)結(jié)構(gòu)定義
typedef struct {
    const char* name;
    int priority;               // 優(yōu)先級(jí)：數(shù)值越大優(yōu)先級(jí)越高
    volatile bool running;      // 任務(wù)運(yùn)行狀態(tài)
    volatile bool blocked;      // 是否阻塞狀態(tài)
    pthread_t tid;              // 線程ID
} Task;

// 內(nèi)核狀態(tài)模擬
volatile Task* current_task = NULL;  // 當(dāng)前運(yùn)行任務(wù)
sem_t network_data_sem;              // 模擬網(wǎng)絡(luò)數(shù)據(jù)到達(dá)的信號(hào)量
volatile bool network_data_ready = false;  // 網(wǎng)絡(luò)數(shù)據(jù)是否就緒

// 定義任務(wù)：等待網(wǎng)絡(luò)數(shù)據(jù)的任務(wù)A和就緒任務(wù)B
Task taskA = {"TaskA", 2, false, false, 0};  // 會(huì)阻塞等待數(shù)據(jù)的任務(wù)
Task taskB = {"TaskB", 2, false, false, 0};  // 可運(yùn)行的其他任務(wù)

// 調(diào)度器：選擇最高優(yōu)先級(jí)的非阻塞任務(wù)
Task* scheduler() {
    // 優(yōu)先選擇非阻塞的任務(wù)
    if (taskB.running && !taskB.blocked) return &taskB;
    if (taskA.running && !taskA.blocked) return &taskA;
    return NULL;
}

// 模擬上下文切換
void context_switch(Task* prev, Task* next) {
    if (prev == next) return;
    printf("\n[調(diào)度器] 發(fā)生搶占：%s (阻塞) -> %s\n", 
           prev->name, next->name);
    current_task = next;
}

// 模擬等待網(wǎng)絡(luò)數(shù)據(jù)（會(huì)進(jìn)入阻塞狀態(tài)）
void wait_for_network_data() {
    printf("[%s] 等待網(wǎng)絡(luò)數(shù)據(jù)到達(dá)...\n", current_task->name);

    // 進(jìn)入阻塞狀態(tài)
    current_task->blocked = true;
    printf("[%s] 數(shù)據(jù)未就緒，進(jìn)入阻塞狀態(tài)\n", current_task->name);

    // 觸發(fā)調(diào)度（因?yàn)楫?dāng)前任務(wù)已阻塞，必須切換）
    Task* next_task = scheduler();
    if (next_task) {
        context_switch(current_task, next_task);
    }

    // 被喚醒后繼續(xù)執(zhí)行（數(shù)據(jù)已就緒）
    printf("[%s] 收到網(wǎng)絡(luò)數(shù)據(jù)，退出阻塞狀態(tài)\n", current_task->name);
    current_task->blocked = false;
}

// 模擬網(wǎng)絡(luò)數(shù)據(jù)到達(dá)（喚醒阻塞任務(wù)）
void network_data_arrived() {
    printf("\n[系統(tǒng)] 網(wǎng)絡(luò)數(shù)據(jù)到達(dá)！喚醒等待任務(wù)\n");
    network_data_ready = true;
    // 將任務(wù)A標(biāo)記為非阻塞
    taskA.blocked = false;
}

// 任務(wù)A的執(zhí)行函數(shù)（等待網(wǎng)絡(luò)數(shù)據(jù)）
void* taskA_func(void* arg) {
    taskA.running = true;
    current_task = &taskA;
    printf("[%s] 開始執(zhí)行，需要接收網(wǎng)絡(luò)數(shù)據(jù)\n", taskA.name);

    // 等待網(wǎng)絡(luò)數(shù)據(jù)（會(huì)進(jìn)入阻塞）
    wait_for_network_data();

    // 處理收到的數(shù)據(jù)
    printf("[%s] 開始處理網(wǎng)絡(luò)數(shù)據(jù)...\n", taskA.name);
    sleep(1);

    taskA.running = false;
    printf("[%s] 任務(wù)執(zhí)行完畢\n", taskA.name);
    return NULL;
}

// 任務(wù)B的執(zhí)行函數(shù)（可被調(diào)度的任務(wù)）
void* taskB_func(void* arg) {
    taskB.running = true;
    // 等待被調(diào)度
    while (current_task != &taskB) {
        usleep(100000);
    }

    printf("[%s] 獲得CPU，開始執(zhí)行任務(wù)\n", taskB.name);

    // 執(zhí)行任務(wù)B的工作
    for (int i = 0; i < 3; i++) {
        printf("[%s] 執(zhí)行處理步驟 %d/3\n", taskB.name, i+1);
        sleep(1);
    }

    // 任務(wù)B完成后，模擬網(wǎng)絡(luò)數(shù)據(jù)到達(dá)
    network_data_arrived();

    // 觸發(fā)調(diào)度，讓任務(wù)A繼續(xù)執(zhí)行
    Task* next_task = scheduler();
    if (next_task) {
        context_switch(current_task, next_task);
    }

    taskB.running = false;
    printf("[%s] 任務(wù)執(zhí)行完畢\n", taskB.name);
    return NULL;
}

int main() {
    // 初始化信號(hào)量（模擬網(wǎng)絡(luò)數(shù)據(jù)同步）
    sem_init(&network_data_sem, 0, 0);

    // 創(chuàng)建任務(wù)線程
    pthread_create(&taskA.tid, NULL, taskA_func, NULL);
    pthread_create(&taskB.tid, NULL, taskB_func, NULL);

    // 等待所有任務(wù)完成
    pthread_join(taskA.tid, NULL);
    pthread_join(taskB.tid, NULL);

    sem_destroy(&network_data_sem);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#include <sched.h>

// 系統(tǒng)狀態(tài)模擬
pthread_spinlock_t config_lock;       // 保護(hù)配置文件的自旋鎖
volatile bool system_running = true;  // 系統(tǒng)運(yùn)行標(biāo)志

// 高優(yōu)先級(jí)實(shí)時(shí)數(shù)據(jù)采集線程函數(shù)
void* realtime_data_thread(void* arg) {
    // 設(shè)置線程為高優(yōu)先級(jí)
    struct sched_param param = {.sched_priority = 90};
    pthread_setschedparam(pthread_self(), SCHED_FIFO, ?m);

    int count = 0;
    while (system_running) {
        // 嘗試獲取CPU執(zhí)行數(shù)據(jù)采集
        printf("\n[高優(yōu)先級(jí)線程] 嘗試采集傳感器數(shù)據(jù)...\n");

        // 模擬數(shù)據(jù)采集和處理（需要及時(shí)執(zhí)行）
        printf("[高優(yōu)先級(jí)線程] 成功采集并處理數(shù)據(jù) #%d\n", ++count);

        // 正常情況下10ms采集一次
        usleep(10000);
    }
    return NULL;
}

// 未優(yōu)化的低優(yōu)先級(jí)配置更新線程函數(shù)（問(wèn)題版本）
void* unoptimized_config_thread(void* arg) {
    // 設(shè)置線程為低優(yōu)先級(jí)
    struct sched_param param = {.sched_priority = 10};
    pthread_setschedparam(pthread_self(), SCHED_FIFO, ?m);

    int update_count = 0;
    while (system_running) {
        // 定期更新配置（每2秒一次）
        sleep(2);
        printf("\n[低優(yōu)先級(jí)線程] 開始更新配置 #%d\n", ++update_count);

        // 獲取自旋鎖（會(huì)禁用內(nèi)核搶占）
        pthread_spin_lock(&config_lock);
        printf("[低優(yōu)先級(jí)線程] 持有自旋鎖，開始處理配置文件...\n");

        // 模擬長(zhǎng)時(shí)間持有鎖進(jìn)行復(fù)雜處理（問(wèn)題根源）
        // 實(shí)際系統(tǒng)中這可能是大量文件IO和數(shù)據(jù)解析
        printf("[低優(yōu)先級(jí)線程] 正在進(jìn)行復(fù)雜的配置解析（長(zhǎng)時(shí)間占用鎖）...\n");
        sleep(3);  // 長(zhǎng)時(shí)間持有鎖，導(dǎo)致高優(yōu)先級(jí)線程無(wú)法搶占

        // 釋放自旋鎖
        pthread_spin_unlock(&config_lock);
        printf("[低優(yōu)先級(jí)線程] 釋放自旋鎖，配置更新完成\n");
    }
    return NULL;
}

// 優(yōu)化后的低優(yōu)先級(jí)配置更新線程函數(shù)
void* optimized_config_thread(void* arg) {
    // 設(shè)置線程為低優(yōu)先級(jí)
    struct sched_param param = {.sched_priority = 10};
    pthread_setschedparam(pthread_self(), SCHED_FIFO, ?m);

    int update_count = 0;
    while (system_running) {
        // 定期更新配置（每2秒一次）
        sleep(2);
        printf("\n[低優(yōu)先級(jí)線程] 開始優(yōu)化版配置更新 #%d\n", ++update_count);

        // 準(zhǔn)備工作：在獲取鎖之前進(jìn)行必要的準(zhǔn)備
        printf("[低優(yōu)先級(jí)線程] 準(zhǔn)備配置數(shù)據(jù)（無(wú)鎖操作）...\n");
        usleep(500000);  // 0.5秒準(zhǔn)備時(shí)間（不持有鎖）

        // 獲取自旋鎖（僅在必要時(shí)持有）
        pthread_spin_lock(&config_lock);
        printf("[低優(yōu)先級(jí)線程] 持有自旋鎖，執(zhí)行關(guān)鍵更新...\n");

        // 僅在鎖內(nèi)執(zhí)行必要的關(guān)鍵操作（大幅縮短持有時(shí)間）
        printf("[低優(yōu)先級(jí)線程] 執(zhí)行核心配置寫入（短時(shí)間占用鎖）...\n");
        usleep(500000);  // 0.5秒關(guān)鍵操作（大幅縮短）

        // 立即釋放自旋鎖
        pthread_spin_unlock(&config_lock);
        printf("[低優(yōu)先級(jí)線程] 釋放自旋鎖\n");

        // 非關(guān)鍵操作放到鎖外執(zhí)行
        printf("[低優(yōu)先級(jí)線程] 執(zhí)行后續(xù)解析和處理（無(wú)鎖操作）...\n");
        usleep(2000000);  // 2秒非關(guān)鍵操作（不影響搶占）
    }
    return NULL;
}

int main(int argc, char* argv[]) {
    // 初始化自旋鎖
    pthread_spin_init(&config_lock, PTHREAD_PROCESS_PRIVATE);

    pthread_t realtime_tid, config_tid;

    // 創(chuàng)建高優(yōu)先級(jí)實(shí)時(shí)線程
    pthread_create(&realtime_tid, NULL, realtime_data_thread, NULL);

    // 根據(jù)參數(shù)選擇運(yùn)行未優(yōu)化或優(yōu)化版本
    if (argc > 1 && argv[1][0] == '1') {
        printf("=== 運(yùn)行未優(yōu)化版本（會(huì)出現(xiàn)優(yōu)先級(jí)反轉(zhuǎn)問(wèn)題） ===\n");
        pthread_create(&config_tid, NULL, unoptimized_config_thread, NULL);
    } else {
        printf("=== 運(yùn)行優(yōu)化版本（解決優(yōu)先級(jí)反轉(zhuǎn)問(wèn)題） ===\n");
        pthread_create(&config_tid, NULL, optimized_config_thread, NULL);
    }

    // 運(yùn)行5秒后結(jié)束
    sleep(5);
    system_running = false;

    // 等待線程結(jié)束
    pthread_join(realtime_tid, NULL);
    pthread_join(config_tid, NULL);

    // 銷毀自旋鎖
    pthread_spin_destroy(&config_lock);
    return 0;
}