Debian下C++多线程编程实践指南

Debian系统支持多种C++多线程编程方式，其中C++11标准库的<thread>（推荐）和**POSIX线程库（pthread）**是最常用的两种。以下从环境准备、基础示例、同步机制到进阶实践，逐步讲解如何在Debian下实现C++多线程编程。

一、环境准备：安装必要工具与库

在Debian上编写C++多线程程序前，需确保系统已安装g++编译器及线程库：

sudo apt update
sudo apt install g++ build-essential  # 安装g++及编译工具链

C++11的<thread>库已集成到libstdc++中，无需额外安装；若使用pthread库，Debian通常预装，如需更新可运行：

sudo apt install libpthread-stubs0-dev

二、C++11线程库实践（推荐）

C++11的<thread>库提供了更简洁、面向对象的线程管理接口，避免了pthread的繁琐操作。

1. 基础线程创建与等待

以下示例创建一个线程执行print_hello函数，主线程等待其完成：

#include <iostream>
#include <thread>

// 线程函数：无参数、无返回值
void print_hello() {
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    // 创建线程：传递函数名作为参数
    std::thread t(print_hello);
    
    // 主线程继续执行
    std::cout << "Hello from the main thread!" << std::endl;
    
    // 等待子线程结束（必须调用，否则程序可能提前退出）
    t.join();
    
    return 0;
}

编译命令（启用C++11标准）：

g++ -std=c++11 -pthread multithreading_example.cpp -o multithreading_example

运行结果（顺序可能不同）：

Hello from the main thread!
Hello from a thread!

2. 传递参数给线程函数

线程函数可以接受参数，但需注意参数会被复制（若需修改原数据，需传递指针或引用，并配合互斥锁）：

#include <iostream>
#include <thread>

// 线程函数：接受int参数
void print_number(int num) {
    std::cout << "Thread received number: " << num << std::endl;
}

int main() {
    int value = 42;
    // 传递参数（自动复制）
    std::thread t(print_number, value);
    t.join();
    
    // 传递引用（需用std::ref包装）
    int ref_value = 100;
    std::thread t2(print_number, std::ref(ref_value));
    t2.join();
    
    return 0;
}

3. 多线程并发执行

创建多个线程并发执行任务，例如打印不同范围的数字：

#include <iostream>
#include <thread>
#include <vector>

void print_range(int start, int end) {
    for (int i = start; i <= end; ++i) {
        std::cout << "Thread " << std::this_thread::get_id() << ": " << i << std::endl;
    }
}

int main() {
    const int num_threads = 3;
    std::vector<std::thread> threads;  // 存储线程对象
    
    // 创建3个线程，分别处理不同范围
    for (int i = 0; i < num_threads; ++i) {
        int start = i * 10 + 1;
        int end = start + 9;
        threads.emplace_back(print_range, start, end);
    }
    
    // 等待所有线程结束
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

三、pthread库实践（传统方式）

若需兼容C语言或旧项目，可使用pthread库，但需注意其接口为C风格，需手动管理线程生命周期。

1. 基础线程创建与等待

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

// 线程函数：返回void*，参数为void*
void* print_hello(void* arg) {
    std::cout << "Hello from a pthread!" << std::endl;
    return nullptr;
}

int main() {
    pthread_t thread_id;
    
    // 创建线程：参数依次为线程ID、属性（nullptr表示默认）、线程函数、参数
    if (pthread_create(&thread_id, nullptr, print_hello, nullptr) != 0) {
        std::cerr << "Failed to create thread!" << std::endl;
        return 1;
    }
    
    // 等待线程结束
    if (pthread_join(thread_id, nullptr) != 0) {
        std::cerr << "Failed to join thread!" << std::endl;
        return 1;
    }
    
    return 0;
}

编译命令（链接pthread库）：

g++ -pthread pthread_example.cpp -o pthread_example

2. 互斥锁保护共享资源

多线程访问共享资源（如std::cout）时，需用pthread_mutex_t实现同步：

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

pthread_mutex_t mutex;  // 互斥锁

void* print_numbers(void* arg) {
    int id = *((int*)arg);
    for (int i = 0; i < 3; ++i) {
        pthread_mutex_lock(&mutex);  // 加锁
        std::cout << "Thread " << id << ": " << i << std::endl;
        pthread_mutex_unlock(&mutex);  // 解锁
    }
    return nullptr;
}

int main() {
    pthread_mutex_init(&mutex, nullptr);  // 初始化互斥锁
    
    int ids[2] = {1, 2};
    pthread_t threads[2];
    
    // 创建2个线程
    for (int i = 0; i < 2; ++i) {
        if (pthread_create(&threads[i], nullptr, print_numbers, &ids[i]) != 0) {
            std::cerr << "Failed to create thread " << i << std::endl;
            return 1;
        }
    }
    
    // 等待线程结束
    for (int i = 0; i < 2; ++i) {
        pthread_join(threads[i], nullptr);
    }
    
    pthread_mutex_destroy(&mutex);  // 销毁互斥锁
    return 0;
}

四、关键注意事项

1. 线程同步：多线程访问共享资源（如全局变量、文件句柄）时，必须使用互斥锁（std::mutex或pthread_mutex_t）、条件变量等机制，避免竞态条件。
2. 线程生命周期：主线程退出前必须调用join()（等待子线程结束）或detach()（分离子线程，由其自行回收资源），否则程序可能崩溃。
3. 编译选项：使用C++11线程时添加-std=c++11 -pthread；使用pthread时添加-pthread，确保链接正确。
4. 性能考虑：线程创建与销毁有开销，频繁创建/销毁线程会影响性能，建议使用线程池（如boost::asio::thread_pool）复用线程。

通过以上实践，可在Debian系统上实现高效的C++多线程程序。根据项目需求选择合适的线程库，注重同步与资源管理，即可构建稳定、并发的应用。