register unsigned long current_stack_pointer asm ("sp");
static inline struct thread_info *current_thread_info(void)  
{                                                           
        return (struct thread_info *)                        
                (current_stack_pointer & ~(THREAD_SIZE - 1));
}                                                            
#define get_current() (current_thread_info()->task)
#define current get_current()

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

// 線程函數(shù)，打印線程ID和棧上變量地址
void *thread_function(void *arg) {
    int thread_num = *(int *)arg;
    free(arg); // 釋放動(dòng)態(tài)分配的內(nèi)存

    // 在棧上創(chuàng)建一個(gè)變量
    int stack_variable;

    // 打印線程ID和棧變量地址
    printf("線程 %d: pthread ID = %lu, 棧變量地址 = %p\n",
           thread_num,
           (unsigned long)pthread_self(),
           &stack_variable);

    // 簡(jiǎn)單的循環(huán)，讓線程持續(xù)一段時(shí)間
    for (int i = 0; i < 5; i++) {
        usleep(100000); // 休眠0.1秒
    }

    return NULL;
}

int main() {
    const int NUM_THREADS = 5;
    pthread_t threads[NUM_THREADS];

    printf("主線程: pthread ID = %lu\n", (unsigned long)pthread_self());

    // 創(chuàng)建多個(gè)線程
    for (int i = 0; i < NUM_THREADS; i++) {
        // 動(dòng)態(tài)分配內(nèi)存?zhèn)鬟f參數(shù)，避免競(jìng)爭(zhēng)條件
        int *thread_num = malloc(sizeof(int));
        *thread_num = i + 1;

        int result = pthread_create(&threads[i], NULL, thread_function, thread_num);
        if (result != 0) {
            fprintf(stderr, "創(chuàng)建線程 %d 失敗\n", i + 1);
            return 1;
        }
    }

    // 等待所有線程完成
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("所有線程已完成\n");
    return 0;
}

gcc thread_demo.c -o thread_demo -lpthread
./thread_demo

主線程: pthread ID = 140572037066560
線程 1: pthread ID = 140572020367104, 棧變量地址 = 0x7fda3a6f9e5c
線程 2: pthread ID = 140572011974400, 棧變量地址 = 0x7fda39ef8e5c
線程 3: pthread ID = 140572003581696, 棧變量地址 = 0x7fda396f7e5c
線程 4: pthread ID = 140571995188992, 棧變量地址 = 0x7fda38ef6e5c
線程 5: pthread ID = 140571986796288, 棧變量地址 = 0x7fda386f5e5c
所有線程已完成

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>

// 全局變量，用于計(jì)數(shù)遞歸深度
volatile int recursion_depth = 0;

// 信號(hào)處理函數(shù)，捕獲段錯(cuò)誤信號(hào)
void handle_sigsegv(int sig) {
    printf("\n捕獲到段錯(cuò)誤(SIGSEGV)！遞歸深度: %d\n", recursion_depth);
    printf("這是由于棧溢出觸發(fā)了guard page保護(hù)機(jī)制\n");
    exit(EXIT_FAILURE);
}

// 遞歸函數(shù)，不斷消耗?？臻g
void recursive_function() {
    // 在棧上分配一塊內(nèi)存，增加棧使用量
    char stack_buffer[1024];
    memset(stack_buffer, 0, sizeof(stack_buffer));

    // 增加遞歸深度計(jì)數(shù)
    recursion_depth++;

    // 每100次遞歸打印一次狀態(tài)
    if (recursion_depth % 100 == 0) {
        printf("遞歸深度: %d, 棧變量地址: %p\n", recursion_depth, stack_buffer);
    }

    // 繼續(xù)遞歸，直到棧溢出
    recursive_function();
}

// 線程函數(shù)
void *thread_function(void *arg) {
    printf("線程開(kāi)始運(yùn)行，嘗試遞歸直到棧溢出...\n");

    // 調(diào)用遞歸函數(shù)，開(kāi)始消耗?？臻g
    recursive_function();

    return NULL;
}

int main() {
    pthread_t thread;
    pthread_attr_t attr;
    size_t stack_size;

    // 注冊(cè)信號(hào)處理函數(shù)，捕獲段錯(cuò)誤
    signal(SIGSEGV, handle_sigsegv);

    // 初始化線程屬性
    pthread_attr_init(&attr);

    // 獲取默認(rèn)棧大小
    pthread_attr_getstacksize(&attr, &stack_size);
    printf("線程默認(rèn)棧大小: %zu 字節(jié)\n", stack_size);

    // 可以在這里設(shè)置更小的棧大小，讓溢出更快發(fā)生
    // stack_size = 1024 * 64; // 64KB
    // pthread_attr_setstacksize(&attr, stack_size);
    // printf("已設(shè)置線程棧大小: %zu 字節(jié)\n", stack_size);

    // 創(chuàng)建線程
    if (pthread_create(&thread, &attr, thread_function, NULL) != 0) {
        fprintf(stderr, "創(chuàng)建線程失敗\n");
        return 1;
    }

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

    // 銷(xiāo)毀線程屬性
    pthread_attr_destroy(&attr);

    return 0;
}

gcc stack_overflow_demo.c -o stack_overflow_demo -lpthread
./stack_overflow_demo

線程默認(rèn)棧大小: 8388608 字節(jié)
線程開(kāi)始運(yùn)行，嘗試遞歸直到棧溢出...
遞歸深度: 100, 棧變量地址: 0x7f8a5f5f7bb0
遞歸深度: 200, 棧變量地址: 0x7f8a5f5f7770
...
遞歸深度: 7800, 棧變量地址: 0x7f8a5ef7fbb0

捕獲到段錯(cuò)誤(SIGSEGV)！遞歸深度: 7842
這是由于棧溢出觸發(fā)了guard page保護(hù)機(jī)制

#include <stdio.h>

void recursive_function(int depth) {
    int local_variable[1024]; // 占用1024個(gè)整型的?？臻g
    printf("Depth: %d\n", depth);
    recursive_function(depth + 1);
}

int main() {
    recursive_function(1);
    return 0;
}

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

void* thread_function(void* arg) {
    // 線程執(zhí)行的任務(wù)
    return NULL;
}

int main() {
    pthread_t thread;
    if (pthread_create(&thread, NULL, thread_function, NULL) != 0) {
        perror("pthread_create");
        return 1;
    }
    // 沒(méi)有調(diào)用pthread_join回收線程資源
    return 0;
}

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

void* thread_function(void* arg) {
    // 線程執(zhí)行的任務(wù)
    pthread_detach(pthread_self()); // 將自身設(shè)置為unjoinable狀態(tài)
    return NULL;
}

int main() {
    pthread_t thread;
    if (pthread_create(&thread, NULL, thread_function, NULL) != 0) {
        perror("pthread_create");
        return 1;
    }
    // 不需要調(diào)用pthread_join
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

// 線程計(jì)數(shù)
volatile int thread_count = 0;

// 簡(jiǎn)單的線程函數(shù)，什么也不做，立即返回
void *thread_function(void *arg) {
    // 線程不需要執(zhí)行任何操作，立即退出
    return NULL;
}

int main() {
    pthread_t *threads;
    int max_threads = 1000000; // 嘗試創(chuàng)建最多100萬(wàn)個(gè)線程
    int i, result;

    // 分配存儲(chǔ)線程ID的數(shù)組
    threads = (pthread_t *)malloc(max_threads * sizeof(pthread_t));
    if (threads == NULL) {
        fprintf(stderr, "內(nèi)存分配失敗\n");
        return 1;
    }

    printf("開(kāi)始創(chuàng)建線程...\n");
    printf("每個(gè)線程默認(rèn)棧大小約為8MB\n");

    // 嘗試創(chuàng)建盡可能多的線程
    for (i = 0; i < max_threads; i++) {
        result = pthread_create(&threads[i], NULL, thread_function, NULL);

        if (result != 0) {
            // 檢查是否是資源暫時(shí)不可用的錯(cuò)誤
            if (result == EAGAIN) {
                fprintf(stderr, "\n創(chuàng)建第 %d 個(gè)線程失敗: %s\n", i + 1, strerror(result));
                fprintf(stderr, "虛擬地址空間耗盡 - 無(wú)法創(chuàng)建更多線程\n");
            } else {
                fprintf(stderr, "\n創(chuàng)建第 %d 個(gè)線程失敗: %s\n", i + 1, strerror(result));
            }
            break;
        }

        thread_count++;

        // 每創(chuàng)建1000個(gè)線程打印一次進(jìn)度
        if (thread_count % 1000 == 0) {
            printf("已創(chuàng)建 %d 個(gè)線程...\r", thread_count);
            fflush(stdout);
        }
    }

    printf("\n成功創(chuàng)建的線程總數(shù): %d\n", thread_count);
    printf("估計(jì)消耗的?？臻g: %.2f GB\n", (thread_count * 8.0) / 1024.0);

    // 等待所有線程完成
    for (i = 0; i < thread_count; i++) {
        pthread_join(threads[i], NULL);
    }

    free(threads);
    return 0;
}

gcc thread_limit_demo.c -o thread_limit_demo -lpthread
./thread_limit_demo

開(kāi)始創(chuàng)建線程...
每個(gè)線程默認(rèn)棧大小約為8MB
已創(chuàng)建 10000 個(gè)線程...
...
創(chuàng)建第 123456 個(gè)線程失敗: Resource temporarily unavailable
虛擬地址空間耗盡 - 無(wú)法創(chuàng)建更多線程
成功創(chuàng)建的線程總數(shù): 123455
估計(jì)消耗的棧空間: 964.50 GB

#include <iostream>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <chrono>
#include <thread>

// 遞歸深度計(jì)數(shù)器
volatile int recursion_depth = 0;
// 最大遞歸深度
const int MAX_RECURSION_DEPTH = 1000;

// 遞歸函數(shù) - 模擬需要較大棧空間的計(jì)算密集型任務(wù)
void recursive_task(int current_depth) {
    // 在棧上分配一些數(shù)據(jù)，模擬棧幀大?。s1KB）
    char stack_data[1024];
    memset(stack_data, 0, sizeof(stack_data));

    recursion_depth = current_depth;

    // 每100層遞歸打印一次狀態(tài)
    if (current_depth % 100 == 0) {
        printf("遞歸深度: %d, 棧數(shù)據(jù)地址: %p\n", current_depth, stack_data);
    }

    // 繼續(xù)遞歸，直到達(dá)到最大深度
    if (current_depth < MAX_RECURSION_DEPTH) {
        recursive_task(current_depth + 1);
    }
}

// 計(jì)算密集型任務(wù)的線程函數(shù)
void *compute_intensive_task(void *arg) {
    int task_id = *(int *)arg;
    free(arg);

    printf("計(jì)算密集型任務(wù) %d 開(kāi)始執(zhí)行\(zhòng)n", task_id);

    // 執(zhí)行遞歸任務(wù)
    recursive_task(1);

    printf("計(jì)算密集型任務(wù) %d 完成，最大遞歸深度: %d\n", task_id, recursion_depth);
    return NULL;
}

// IO密集型任務(wù)的線程函數(shù)
void *io_intensive_task(void *arg) {
    int task_id = *(int *)arg;
    free(arg);

    printf("IO密集型任務(wù) %d 開(kāi)始執(zhí)行\(zhòng)n", task_id);

    // 模擬IO操作 - 多次短暫休眠
    for (int i = 0; i < 5; i++) {
        printf("IO密集型任務(wù) %d 正在等待IO操作...\n", task_id);
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }

    printf("IO密集型任務(wù) %d 完成\n", task_id);
    return NULL;
}

int main() {
    pthread_t compute_thread, io_thread;
    pthread_attr_t compute_attr, io_attr;
    size_t default_stack_size;

    // 初始化線程屬性
    pthread_attr_init(&compute_attr);
    pthread_attr_init(&io_attr);

    // 獲取默認(rèn)棧大小
    pthread_attr_getstacksize(&compute_attr, &default_stack_size);
    printf("默認(rèn)線程棧大小: %zu 字節(jié)\n", default_stack_size);

    // 為計(jì)算密集型任務(wù)設(shè)置棧大小
    // 每個(gè)遞歸調(diào)用約1KB，最大深度1000，加上20%余量 = 1200KB
    size_t compute_stack_size = 1200 * 1024; // 1200KB
    pthread_attr_setstacksize(&compute_attr, compute_stack_size);
    printf("為計(jì)算密集型任務(wù)設(shè)置棧大小: %zu 字節(jié)\n", compute_stack_size);

    // 為IO密集型任務(wù)設(shè)置棧大小
    size_t io_stack_size = 512 * 1024; // 512KB
    pthread_attr_setstacksize(&io_attr, io_stack_size);
    printf("為IO密集型任務(wù)設(shè)置棧大小: %zu 字節(jié)\n", io_stack_size);

    // 創(chuàng)建計(jì)算密集型任務(wù)線程
    int *compute_task_id = (int *)malloc(sizeof(int));
    *compute_task_id = 1;
    if (pthread_create(&compute_thread, &compute_attr, compute_intensive_task, compute_task_id) != 0) {
        fprintf(stderr, "創(chuàng)建計(jì)算密集型任務(wù)線程失敗\n");
        return 1;
    }

    // 創(chuàng)建IO密集型任務(wù)線程
    int *io_task_id = (int *)malloc(sizeof(int));
    *io_task_id = 1;
    if (pthread_create(&io_thread, &io_attr, io_intensive_task, io_task_id) != 0) {
        fprintf(stderr, "創(chuàng)建IO密集型任務(wù)線程失敗\n");
        return 1;
    }

    // 等待線程完成
    pthread_join(compute_thread, NULL);
    pthread_join(io_thread, NULL);

    // 銷(xiāo)毀線程屬性
    pthread_attr_destroy(&compute_attr);
    pthread_attr_destroy(&io_attr);

    printf("所有任務(wù)完成\n");
    return 0;
}

g++ thread_stack_demo.cpp -o thread_stack_demo -lpthread
./thread_stack_demo

默認(rèn)線程棧大小: 8388608 字節(jié)
為計(jì)算密集型任務(wù)設(shè)置棧大小: 1228800 字節(jié)
為IO密集型任務(wù)設(shè)置棧大小: 524288 字節(jié)
計(jì)算密集型任務(wù) 1 開(kāi)始執(zhí)行
遞歸深度: 100, 棧數(shù)據(jù)地址: 0x7f5c8b3f8b60
遞歸深度: 200, 棧數(shù)據(jù)地址: 0x7f5c8b3f8720
...
遞歸深度: 1000, 棧數(shù)據(jù)地址: 0x7f5c8b3f4b60
計(jì)算密集型任務(wù) 1 完成，最大遞歸深度: 1000
IO密集型任務(wù) 1 開(kāi)始執(zhí)行
IO密集型任務(wù) 1 正在等待IO操作...
...
IO密集型任務(wù) 1 完成
所有任務(wù)完成

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

void* background_task(void* arg) {
    // 后臺(tái)任務(wù)的具體邏輯
    return NULL;
}

int main() {
    pthread_t thread;
    if (pthread_create(&thread, NULL, background_task, NULL) != 0) {
        perror("pthread_create");
        return 1;
    }
    if (pthread_detach(thread) != 0) {
        perror("pthread_detach");
        return 1;
    }
    return 0;
}

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

#define THREAD_NUM 5

void* data_processing(void* arg) {
    int id = *(int*)arg;
    // 數(shù)據(jù)處理的具體邏輯
    return (void*)(long)id;
}

int main() {
    pthread_t threads[THREAD_NUM];
    int ids[THREAD_NUM];
    void* results[THREAD_NUM];

    for (int i = 0; i < THREAD_NUM; i++) {
        ids[i] = i;
        if (pthread_create(&threads[i], NULL, data_processing, &ids[i]) != 0) {
            perror("pthread_create");
            return 1;
        }
    }

    for (int i = 0; i < THREAD_NUM; i++) {
        if (pthread_join(threads[i], &results[i]) != 0) {
            perror("pthread_join");
            return 1;
        }
        printf("Thread %d returned: %ld\n", (int)(long)results[i], (long)results[i]);
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>
#include <chrono>
#include <cmath>
#include <numeric>

// 線程池類(lèi)
class ThreadPool {
private:
    // 工作線程數(shù)量
    size_t num_threads;
    // 工作線程容器
    std::vector<std::thread> workers;
    // 任務(wù)隊(duì)列
    std::queue<std::function<void()>> tasks;

    // 同步機(jī)制
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;

public:
    // 構(gòu)造函數(shù)，默認(rèn)線程數(shù)為CPU核心數(shù)×2
    ThreadPool(size_t threads = std::thread::hardware_concurrency() * 2) 
        : num_threads(threads), stop(false) {

        // 創(chuàng)建工作線程
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                // 工作線程循環(huán)，處理任務(wù)
                while (true) {
                    std::function<void()> task;

                    // 加鎖獲取任務(wù)
                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        // 等待任務(wù)或停止信號(hào)
                        this->condition.wait(lock, 
                            [this] { return this->stop || !this->tasks.empty(); });

                        // 如果停止且任務(wù)隊(duì)列為空，則退出
                        if (this->stop && this->tasks.empty())
                            return;

                        // 獲取任務(wù)
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }

                    // 執(zhí)行任務(wù)
                    task();
                }
            });
        }

        std::cout << "線程池初始化完成，工作線程數(shù)量: " << threads << std::endl;
        std::cout << "系統(tǒng)CPU核心數(shù): " << std::thread::hardware_concurrency() << std::endl;
    }

    // 析構(gòu)函數(shù)，停止所有工作線程
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }

        // 喚醒所有工作線程
        condition.notify_all();

        // 等待所有工作線程完成
        for (std::thread &worker : workers)
            worker.join();

        std::cout << "線程池已關(guān)閉" << std::endl;
    }

    // 向任務(wù)隊(duì)列添加任務(wù)
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type> {

        using return_type = typename std::result_of<F(Args...)>::type;

        // 包裝任務(wù)為shared_ptr
        auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        // 獲取future用于獲取任務(wù)結(jié)果
        std::future<return_type> res = task->get_future();

        // 將任務(wù)添加到隊(duì)列
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            // 如果線程池已停止，不能添加任務(wù)
            if (stop)
                throw std::runtime_error("向已停止的線程池添加任務(wù)");

            tasks.emplace([task]() { (*task)(); });
        }

        // 喚醒一個(gè)工作線程
        condition.notify_one();

        return res;
    }
};

// 模擬CPU密集型任務(wù)：計(jì)算素?cái)?shù)
bool is_prime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;

    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    }
    return true;
}

// 模擬IO密集型任務(wù)：休眠一段時(shí)間
void io_task(int task_id, int delay_ms) {
    std::this_thread::sleep_for(std::chrono::milliseconds(delay_ms));
    std::cout << "IO任務(wù) " << task_id << " 完成，耗時(shí) " << delay_ms << "ms\n";
}

int main() {
    // 創(chuàng)建線程池，使用默認(rèn)線程數(shù)(CPU核心數(shù)×2)
    ThreadPool pool;

    // 存儲(chǔ)任務(wù)的future
    std::vector<std::future<bool>> prime_results;
    std::vector<std::future<void>> io_results;

    std::cout << "\n=== 提交CPU密集型任務(wù) ===" << std::endl;
    // 提交一系列CPU密集型任務(wù)：檢查大數(shù)字是否為素?cái)?shù)
    for (int i = 0; i < 20; ++i) {
        int num = 100000000 + i * 10000 + rand() % 10000;
        prime_results.emplace_back(
            pool.enqueue(is_prime, num)
        );

        // 打印提交狀態(tài)
        if (i % 5 == 0) {
            std::cout << "已提交 " << i + 1 << " 個(gè)素?cái)?shù)檢查任務(wù)\n";
        }
    }

    std::cout << "\n=== 提交IO密集型任務(wù) ===" << std::endl;
    // 提交一系列IO密集型任務(wù)
    for (int i = 0; i < 15; ++i) {
        int delay = 100 + rand() % 400; // 100-500ms隨機(jī)延遲
        io_results.emplace_back(
            pool.enqueue(io_task, i + 1, delay)
        );

        if (i % 5 == 0) {
            std::cout << "已提交 " << i + 1 << " 個(gè)IO任務(wù)\n";
        }
    }

    // 等待所有CPU任務(wù)完成并輸出結(jié)果
    std::cout << "\n=== CPU任務(wù)結(jié)果 ===" << std::endl;
    for (size_t i = 0; i < prime_results.size(); ++i) {
        int num = 100000000 + i * 10000 + rand() % 10000;
        bool result = prime_results[i].get();
        std::cout << "數(shù)字 " << num << (result ? " 是" : " 不是") << " 素?cái)?shù)\n";
    }

    // 等待所有IO任務(wù)完成
    std::cout << "\n=== 等待所有IO任務(wù)完成 ===" << std::endl;
    for (auto &f : io_results) {
        f.get();
    }

    std::cout << "\n所有任務(wù)處理完畢" << std::endl;
    return 0;
}

g++ -std=c++11 thread_pool.cpp -o thread_pool -lpthread
./thread_pool

#include <stdio.h>

int fibonacci_recursive(int n) {
    if (n == 0 || n == 1) {
        return n;
    }
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
}

int main() {
    int n = 30;
    int result = fibonacci_recursive(n);
    printf("Fibonacci(%d) = %d\n", n, result);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int n;
    int result;
} StackFrame;

int fibonacci_iterative(int n) {
    StackFrame *stack = (StackFrame*)malloc((n + 1) * sizeof(StackFrame));
    if (stack == NULL) {
        perror("malloc");
        return -1;
    }
    int top = -1;

    stack[++top].n = n;
    while (top >= 0) {
        StackFrame *current = &stack[top];
        if (current->n == 0 || current->n == 1) {
            current->result = current->n;
            top--;
            if (top >= 0) {
                StackFrame *parent = &stack[top];
                if (parent->n == current->n + 1) {
                    parent->result += current->result;
                } else {
                    stack[++top].n = parent->n - 2;
                }
            }
        } else {
            stack[++top].n = current->n - 1;
        }
    }

    int result = stack[0].result;
    free(stack);
    return result;
}

int main() {
    int n = 30;
    int result = fibonacci_iterative(n);
    printf("Fibonacci(%d) = %d\n", n, result);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <signal.h>

// 全局變量，控制線程運(yùn)行
volatile int running = 1;

// 線程函數(shù)，簡(jiǎn)單休眠等待
void *thread_function(void *arg) {
    int thread_num = *(int *)arg;
    free(arg);

    printf("線程 %d 啟動(dòng)，TID: %lu，PID: %d\n", 
           thread_num, (unsigned long)pthread_self(), getpid());

    // 線程循環(huán)等待，保持存活以便查看信息
    while (running) {
        sleep(1);
    }

    printf("線程 %d 退出\n", thread_num);
    return NULL;
}

// 讀取并解析/proc/[pid]/task/[tid]/maps文件，查找棧信息
void print_thread_stack_info(pid_t pid, pthread_t tid) {
    char filename[256];
    FILE *file;
    char line[1024];

    // 構(gòu)造maps文件路徑
    snprintf(filename, sizeof(filename), "/proc/%d/task/%lu/maps", pid, (unsigned long)tid);

    // 打開(kāi)文件
    file = fopen(filename, "r");
    if (!file) {
        fprintf(stderr, "無(wú)法打開(kāi)文件 %s: %s\n", filename, strerror(errno));
        return;
    }

    printf("\n線程 TID: %lu 的內(nèi)存映射信息 (棧相關(guān)部分):\n", (unsigned long)tid);
    printf("-------------------------------------------------\n");

    // 讀取文件內(nèi)容，查找棧相關(guān)的條目
    while (fgets(line, sizeof(line), file)) {
        // 棧通常標(biāo)記為 "[stack]" 或沒(méi)有明確標(biāo)記但具有讀寫(xiě)權(quán)限
        if (strstr(line, "[stack]") || 
            (strstr(line, "rw-p") && !strstr(line, " [") && !strstr(line, "/"))) {
            printf("%s", line);
        }
    }

    printf("-------------------------------------------------\n");
    fclose(file);
}

int main() {
    const int NUM_THREADS = 3;
    pthread_t threads[NUM_THREADS];
    pid_t pid = getpid();

    printf("主線程啟動(dòng)，PID: %d\n", pid);
    printf("將創(chuàng)建 %d 個(gè)子線程...\n", NUM_THREADS);

    // 創(chuàng)建多個(gè)線程
    for (int i = 0; i < NUM_THREADS; i++) {
        int *thread_num = malloc(sizeof(int));
        *thread_num = i + 1;

        if (pthread_create(&threads[i], NULL, thread_function, thread_num) != 0) {
            fprintf(stderr, "創(chuàng)建線程 %d 失敗\n", i + 1);
            return 1;
        }
    }

    // 等待所有線程啟動(dòng)
    sleep(2);

    // 查看每個(gè)線程的棧信息
    for (int i = 0; i < NUM_THREADS; i++) {
        print_thread_stack_info(pid, threads[i]);
    }

    printf("\n線程棧信息已顯示完畢\n");
    printf("提示: 你也可以在終端中運(yùn)行以下命令查看詳細(xì)信息:\n");
    for (int i = 0; i < NUM_THREADS; i++) {
        printf("  cat /proc/%d/task/%lu/maps\n", pid, (unsigned long)threads[i]);
    }

    // 通知線程退出并等待
    running = 0;
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("\n所有線程已退出\n");
    return 0;
}

gcc proc_thread_stack.c -o proc_thread_stack -lpthread
./proc_thread_stack

主線程啟動(dòng)，PID: 12345
將創(chuàng)建 3 個(gè)子線程...
線程 1 啟動(dòng)，TID: 12346，PID: 12345
線程 2 啟動(dòng)，TID: 12347，PID: 12345
線程 3 啟動(dòng)，TID: 12348，PID: 12345

線程 TID: 12346 的內(nèi)存映射信息 (棧相關(guān)部分):
-------------------------------------------------
7f8a3a6f9000-7f8a3a77a000 rw-p 00000000 00:00 0                          [stack]
-------------------------------------------------
...

提示: 你也可以在終端中運(yùn)行以下命令查看詳細(xì)信息:
  cat /proc/12345/task/12346/maps
  cat /proc/12345/task/12347/maps
  cat /proc/12345/task/12348/maps

所有線程已退出

#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>
#include <string.h>
#include <errno.h>

// 遞歸函數(shù)，用于測(cè)試棧大小
void recursive_test(int depth) {
    // 在棧上分配一些內(nèi)存
    char stack_buffer[1024];

    // 每100層打印一次信息
    if (depth % 100 == 0) {
        printf("遞歸深度: %d, 棧位置: %p\n", depth, stack_buffer);
    }

    // 繼續(xù)遞歸
    recursive_test(depth + 1);
}

// 打印當(dāng)前棧大小限制
void print_stack_limit() {
    struct rlimit rl;

    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("當(dāng)前棧大小限制:\n");
        printf("  軟限制: %lld KB\n", (long long)rl.rlim_cur / 1024);
        printf("  硬限制: %lld KB\n", (long long)rl.rlim_max / 1024);
    } else {
        fprintf(stderr, "獲取棧限制失敗: %s\n", strerror(errno));
    }
}

// 設(shè)置棧大小限制
int set_stack_limit(size_t new_soft_limit_kb, size_t new_hard_limit_kb) {
    struct rlimit rl;

    // 轉(zhuǎn)換為字節(jié)
    rl.rlim_cur = new_soft_limit_kb * 1024;
    rl.rlim_max = new_hard_limit_kb * 1024;

    if (setrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("已設(shè)置新的棧大小限制:\n");
        printf("  新軟限制: %zu KB\n", new_soft_limit_kb);
        printf("  新硬限制: %zu KB\n", new_hard_limit_kb);
        return 0;
    } else {
        fprintf(stderr, "設(shè)置棧限制失敗: %s\n", strerror(errno));
        return 1;
    }
}

int main() {
    printf("=== 初始棧大小限制 ===\n");
    print_stack_limit();

    // 嘗試將棧大小限制修改為4MB（軟限制）和8MB（硬限制）
    printf("\n=== 嘗試修改棧大小限制 ===\n");
    if (set_stack_limit(4096, 8192) == 0) {
        printf("\n=== 修改后的棧大小限制 ===\n");
        print_stack_limit();
    }

    // 測(cè)試當(dāng)前棧大小
    printf("\n=== 開(kāi)始棧深度測(cè)試 ===\n");
    printf("將遞歸直到棧溢出...\n");

    try {
        recursive_test(1);
    } catch (...) {
        fprintf(stderr, "捕獲到異常，可能是棧溢出\n");
    }

    return 0;
}

gcc stack_limit_demo.c -o stack_limit_demo
./stack_limit_demo

=== 初始棧大小限制 ===
當(dāng)前棧大小限制:
  軟限制: 8192 KB
  硬限制: -1 KB

=== 嘗試修改棧大小限制 ===
已設(shè)置新的棧大小限制:
  新軟限制: 4096 KB
  新硬限制: 8192 KB

=== 修改后的棧大小限制 ===
當(dāng)前棧大小限制:
  軟限制: 4096 KB
  硬限制: 8192 KB

=== 開(kāi)始棧深度測(cè)試 ===
將遞歸直到棧溢出...
遞歸深度: 100, 棧位置: 0x7ffd9b5e96e0
遞歸深度: 200, 棧位置: 0x7ffd9b5e92a0
...
段錯(cuò)誤 (核心已轉(zhuǎn)儲(chǔ))

#0  0x00007ffff7a2b830 in deep_recursion (n=1234) at test.c:12
#1  0x00007ffff7a2b7f0 in deep_recursion (n=1235) at test.c:12
#2  0x00007ffff7a2b7f0 in deep_recursion (n=1236) at test.c:12
#3  0x00007ffff7a2b830 in deep_recursion (n=1234) at test.c:12

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/resource.h>

// 線程函數(shù)
void *thread_func(void *arg) {
    int local_var; // 局部變量，存儲(chǔ)在棧上
    printf("子線程: 局部變量地址: %p\n", &local_var);

    // 獲取線程棧大小限制
    struct rlimit rl;
    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("子線程: 棧大小限制 - 軟限制: %ld, 硬限制: %ld\n", 
               (long)rl.rlim_cur, (long)rl.rlim_max);
    }

    sleep(1);
    return NULL;
}

int main() {
    pthread_t tid;
    int ret;

    // 創(chuàng)建線程，使用默認(rèn)棧設(shè)置
    ret = pthread_create(&tid, NULL, thread_func, NULL);
    if (ret != 0) {
        fprintf(stderr, "創(chuàng)建線程失敗\n");
        exit(EXIT_FAILURE);
    }

    printf("主線程: 等待子線程完成...\n");
    pthread_join(tid, NULL);
    printf("主線程: 子線程已結(jié)束\n");

    return 0;
}

gcc default_stack_demo.c -o default_stack -lpthread ./default_stack

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

#define STACK_SIZE (1024 * 1024) // 1MB 棧大小

void *thread_func(void *arg) {
    int local_var;
    printf("子線程: 局部變量地址: %p\n", &local_var);
    printf("子線程: 正在運(yùn)行...\n");
    sleep(1);
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_attr_t attr;
    int ret;
    size_t stack_size;
    void *stack_addr;

    // 初始化線程屬性
    ret = pthread_attr_init(&attr);
    if (ret != 0) {
        fprintf(stderr, "初始化線程屬性失敗: %s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }

    // 分配棧內(nèi)存
    stack_addr = malloc(STACK_SIZE);
    if (stack_addr == NULL) {
        fprintf(stderr, "內(nèi)存分配失敗\n");
        exit(EXIT_FAILURE);
    }

    // 設(shè)置棧大小和棧地址
    ret = pthread_attr_setstack(&attr, stack_addr, STACK_SIZE);
    if (ret != 0) {
        fprintf(stderr, "設(shè)置棧失敗: %s\n", strerror(ret));
        free(stack_addr);
        exit(EXIT_FAILURE);
    }

    // 獲取并打印棧大小
    ret = pthread_attr_getstacksize(&attr, &stack_size);
    if (ret != 0) {
        fprintf(stderr, "獲取棧大小失敗: %s\n", strerror(ret));
    } else {
        printf("主線程: 設(shè)置的線程棧大小為: %zu 字節(jié)\n", stack_size);
    }

    // 創(chuàng)建線程
    ret = pthread_create(&tid, &attr, thread_func, NULL);
    if (ret != 0) {
        fprintf(stderr, "創(chuàng)建線程失敗: %s\n", strerror(ret));
        free(stack_addr);
        exit(EXIT_FAILURE);
    }

    // 等待線程結(jié)束
    pthread_join(tid, NULL);
    printf("主線程: 子線程已結(jié)束\n");

    // 清理資源
    pthread_attr_destroy(&attr);
    free(stack_addr);

    return 0;
}

gcc custom_stack_demo.c -o custom_stack -lpthread
./custom_stack

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

#define SMALL_STACK_SIZE (4096) // 非常小的棧大小

// 遞歸函數(shù)，會(huì)消耗大量?？臻g
void recursive_func(int depth) {
    char large_array[1024]; // 每次遞歸分配1KB
    printf("遞歸深度: %d, 數(shù)組地址: %p\n", depth, large_array);

    // 繼續(xù)遞歸，直到棧溢出
    recursive_func(depth + 1);
}

void *thread_func(void *arg) {
    printf("子線程: 開(kāi)始執(zhí)行，嘗試遞歸調(diào)用...\n");
    recursive_func(1); // 開(kāi)始遞歸
    return NULL; // 這行永遠(yuǎn)不會(huì)執(zhí)行
}

int main() {
    pthread_t tid;
    pthread_attr_t attr;
    int ret;
    void *stack_addr;

    // 初始化線程屬性
    ret = pthread_attr_init(&attr);
    if (ret != 0) {
        fprintf(stderr, "初始化線程屬性失敗: %s\n", strerror(ret));
        exit(EXIT_FAILURE);
    }

    // 分配小棧內(nèi)存
    stack_addr = malloc(SMALL_STACK_SIZE);
    if (stack_addr == NULL) {
        fprintf(stderr, "內(nèi)存分配失敗\n");
        exit(EXIT_FAILURE);
    }

    // 設(shè)置小棧大小
    ret = pthread_attr_setstack(&attr, stack_addr, SMALL_STACK_SIZE);
    if (ret != 0) {
        fprintf(stderr, "設(shè)置棧失敗: %s\n", strerror(ret));
        free(stack_addr);
        exit(EXIT_FAILURE);
    }

    // 創(chuàng)建線程
    ret = pthread_create(&tid, &attr, thread_func, NULL);
    if (ret != 0) {
        fprintf(stderr, "創(chuàng)建線程失敗: %s\n", strerror(ret));
        free(stack_addr);
        exit(EXIT_FAILURE);
    }

    // 等待線程結(jié)束
    pthread_join(tid, NULL);
    printf("主線程: 子線程已結(jié)束\n"); // 棧溢出后可能不會(huì)執(zhí)行到這里

    // 清理資源
    pthread_attr_destroy(&attr);
    free(stack_addr);

    return 0;
}

gcc stack_overflow_demo.c -o stack_overflow -lpthread
./stack_overflow