编辑“︁C++ 启动线程”︁（章节）

= C++启动线程 =

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

== 概述 ==

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

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

== 基本语法 ==

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

<syntaxhighlight lang="cpp">
#include <iostream>
#include <thread>

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

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

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

    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Hello from thread!
</pre>

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

== 线程的生命周期管理 ==

线程的生命周期可以通过<code>join()</code>和<code>detach()</code>方法管理：
* <code>join()</code>：阻塞当前线程，直到被调用的线程完成执行。
* <code>detach()</code>：将线程与<code>std::thread</code>对象分离，线程在后台独立运行。

=== 使用<code>detach()</code>的示例 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

'''可能的输出：'''
<pre>
Main thread continues.
Detached thread finished.
</pre>

== 传递参数给线程函数 ==

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

=== 示例：传递参数 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

'''输出：'''
<pre>
Hello from thread with arguments!
</pre>

== 使用Lambda表达式启动线程 ==

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

=== 示例：Lambda表达式 ===
<syntaxhighlight lang="cpp">
#include <iostream>
#include <thread>

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

    return 0;
}
</syntaxhighlight>

'''输出：'''
<pre>
Hello from lambda thread!
</pre>

== 实际应用场景 ==

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

=== 示例：并行计算 ===
以下示例展示如何使用多线程加速向量加法：

<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

'''输出：'''
<pre>
First 10 results: 3 3 3 3 3 3 3 3 3 3
</pre>

== 线程同步与竞态条件 ==

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

=== 示例：使用互斥锁 ===
<syntaxhighlight lang="cpp">
#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;
}
</syntaxhighlight>

'''可能的输出：'''
<pre>
Thread 1 is printing.
Thread 2 is printing.
</pre>

== 线程的状态图 ==

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

<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
</mermaid>

== 数学基础 ==

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

<math>
\text{Atomic}(x) = \begin{cases}
1 & \text{如果操作是原子的} \\
0 & \text{否则}
\end{cases}
</math>

== 总结 ==

C++启动线程是通过<code>std::thread</code>类实现的，它提供了简单而强大的多线程支持。关键点包括：
* 使用<code>std::thread</code>创建线程。
* 通过<code>join()</code>或<code>detach()</code>管理线程生命周期。
* 可以使用函数、Lambda表达式或可调用对象作为线程函数。
* 注意线程同步以避免竞态条件。

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

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 多线程]]