C++ 启动线程

C++启动线程

C++启动线程是指在C++程序中创建并运行一个新的执行线程。多线程是现代编程中实现并发的重要技术，能够显著提高程序的执行效率，特别是在多核处理器上。C++11标准引入了<thread>头文件，提供了原生支持线程操作的功能，使得线程管理更加便捷和安全。

概述

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个进程可以包含多个线程，这些线程共享进程的资源，但每个线程拥有独立的执行路径。在C++中，可以通过标准库中的std::thread类来创建和管理线程。

启动线程的基本步骤包括： 1. 包含<thread>头文件。 2. 定义一个线程函数或可调用对象。 3. 创建std::thread对象，传入线程函数或可调用对象。 4. 调用join()或detach()方法管理线程生命周期。

基本语法

以下是启动线程的基本语法：

#include <iostream>
#include <thread>

// 线程函数
void threadFunction() {
    std::cout << "Hello from thread!\n";
}

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

    // 等待线程完成
    t.join();

    return 0;
}

输出：

Hello from thread!

代码解释

1. threadFunction是一个简单的函数，它将在新线程中执行。 2. std::thread t(threadFunction)创建了一个线程对象t，并立即启动线程执行threadFunction。 3. t.join()确保主线程等待t线程执行完毕后再继续。

线程的生命周期管理

线程的生命周期可以通过join()和detach()方法管理：

• join()：阻塞当前线程，直到被调用的线程完成执行。
• detach()：将线程与std::thread对象分离，线程在后台独立运行。

使用detach()的示例

#include <iostream>
#include <thread>
#include <chrono>

void detachedThreadFunction() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Detached thread finished.\n";
}

int main() {
    std::thread t(detachedThreadFunction);
    t.detach(); // 分离线程

    std::cout << "Main thread continues.\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 确保分离线程有足够时间完成

    return 0;
}

可能的输出：

Main thread continues.
Detached thread finished.

传递参数给线程函数

线程函数可以接受参数，参数通过std::thread的构造函数传递。需要注意的是，参数默认以值传递的方式传入线程函数。如果需要传递引用，必须使用std::ref或std::cref。

示例：传递参数

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << "\n";
}

int main() {
    std::string msg = "Hello from thread with arguments!";
    std::thread t(printMessage, msg); // 传递msg的副本
    t.join();

    return 0;
}

输出：

Hello from thread with arguments!

使用Lambda表达式启动线程

C++11的Lambda表达式可以方便地用于启动线程，尤其适合简单的任务。

示例：Lambda表达式

#include <iostream>
#include <thread>

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

    return 0;
}

输出：

Hello from lambda thread!

实际应用场景

多线程常用于以下场景： 1. 并行计算：将计算任务分配到多个线程以提高性能。 2. 异步I/O：在一个线程中执行I/O操作，避免阻塞主线程。 3. GUI应用程序：保持用户界面的响应性，将耗时操作放在后台线程中。

示例：并行计算

以下示例展示如何使用多线程加速向量加法：

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

// 计算部分向量的和
void partialSum(const std::vector<int>& a, const std::vector<int>& b, std::vector<int>& result, int start, int end) {
    for (int i = start; i < end; ++i) {
        result[i] = a[i] + b[i];
    }
}

int main() {
    const int size = 1000000;
    std::vector<int> a(size, 1); // 全1向量
    std::vector<int> b(size, 2); // 全2向量
    std::vector<int> result(size);

    const int numThreads = 4;
    std::vector<std::thread> threads;

    int chunkSize = size / numThreads;
    for (int i = 0; i < numThreads; ++i) {
        int start = i * chunkSize;
        int end = (i == numThreads - 1) ? size : start + chunkSize;
        threads.emplace_back(partialSum, std::cref(a), std::cref(b), std::ref(result), start, end);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "First 10 results: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << result[i] << " ";
    }
    std::cout << "\n";

    return 0;
}

输出：

First 10 results: 3 3 3 3 3 3 3 3 3 3

线程同步与竞态条件

当多个线程访问共享资源时，可能会出现竞态条件（Race Condition）。C++提供了多种同步机制，如互斥锁（std::mutex）、条件变量（std::condition_variable）等。

示例：使用互斥锁

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // 全局互斥锁

void safePrint(int id) {
    mtx.lock();
    std::cout << "Thread " << id << " is printing.\n";
    mtx.unlock();
}

int main() {
    std::thread t1(safePrint, 1);
    std::thread t2(safePrint, 2);

    t1.join();
    t2.join();

    return 0;
}

可能的输出：

Thread 1 is printing.
Thread 2 is printing.

线程的状态图

以下Mermaid状态图展示了线程的生命周期：

stateDiagram [*] --> Created Created --> Running: thread starts Running --> Terminated: thread finishes Running --> Detached: detach() called Detached --> Terminated: thread finishes Running --> Joined: join() called Joined --> Terminated

数学基础

在多线程编程中，某些操作需要原子性。原子操作可以用以下数学表达式表示：

$\text{Atomic}(x)=\{\begin{array}{ll}1& \text{如果操作是原子的}\\ 0& \text{否则}\end{array}$

总结

C++启动线程是通过std::thread类实现的，它提供了简单而强大的多线程支持。关键点包括：

• 使用std::thread创建线程。
• 通过join()或detach()管理线程生命周期。
• 可以使用函数、Lambda表达式或可调用对象作为线程函数。
• 注意线程同步以避免竞态条件。

掌握这些基础知识后，开发者可以进一步探索更高级的多线程技术，如线程池、异步编程等。