c++ 几十个线程怎么管理|极客教程

c++ 几十个线程怎么管理

概述

在C++中，线程管理是多线程编程中的一个重要方面。对于只有几个线程的程序，线程的创建、销毁和调度相对较为容易。但当线程的数量增多时，如何有效地管理这些线程成为一个挑战。本文将介绍一些在C++中管理多个线程的技巧和最佳实践。

1. 线程创建和销毁

在C++中，可以使用标准库提供的 std::thread 类来创建和管理线程。以下是创建线程的基本步骤：

包含头文件 <thread> 和 <iostream>：
```
#include <thread>
#include <iostream>
```
C++

定义一个函数作为线程的入口点：

void threadFunc() {
   // 线程要执行的代码
}

在 main 函数中创建线程并执行：

int main() {
   std::thread myThread(threadFunc); // 创建线程
   myThread.join(); // 等待线程执行结束
   return 0;
}

在上述示例中，我们创建了一个名为 myThread 的线程，并将 threadFunc 函数作为线程的入口点。myThread.join() 表示主线程等待 myThread 线程执行结束后再继续执行。

销毁线程时，可以调用 std::thread 类的 join() 或 detach() 方法。join() 方法会实现线程的同步，即主线程等待当前线程执行完毕；而 detach() 方法则是将线程“分离”，使其在后台运行，不再与主线程有关联。注意，如果没有调用 join() 或 detach()，程序会抛出 std::terminate 异常。

2. 线程池

线程池是一种常见的多线程管理策略，它通过维护一个线程队列，提供可复用的线程来执行任务。使用线程池可以避免频繁地创建和销毁线程，提高性能和线程管理的效率。

在C++中，可以借助第三方库如 Boost 或 Poco 来实现线程池，也可以自己实现一个简单的线程池。

以下是一个简单的线程池示例：

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

class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stopFlag(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { return stopFlag || !tasks.empty(); });
                        if (stopFlag && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stopFlag = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

    template <class F, class... Args>
    void enqueue(F&& f, Args&&... args) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            tasks.emplace([f = std::forward<F>(f), ...args = std::forward<Args>(args)]() { f(args...); });
        }
        condition.notify_one();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stopFlag;
};

// 示例使用方法
void taskFunc(int taskId) {
    std::cout << "Task " << taskId << " is running." << std::endl;
}

int main() {
    ThreadPool threadPool(4); // 创建包含4个线程的线程池
    for (int i = 0; i < 10; ++i) {
        threadPool.enqueue(taskFunc, i); // 提交任务到线程池
    }
    return 0;
}

上述示例中，我们定义了一个 ThreadPool 类，它接受一个参数 numThreads 来指定线程池中线程的数量。在构造函数中，我们先创建了指定数量的线程，并将它们放入一个 workers 向量中。每个线程执行的逻辑是从任务队列中取出任务并执行，直到收到停止信号。任务队列使用 std::queue 实现，互斥访问通过 std::mutex 和 std::unique_lock 实现。当向线程池提交任务时，我们使用了可变参数模板和 std::function，通过 std::move 避免了拷贝构造，提高了效率。

3. 线程同步与通信

在多线程编程中，线程之间的同步与通信是一个重要的问题。在C++中，可以使用互斥锁（std::mutex）、条件变量（std::condition_variable）和原子操作（std::atomic）等机制来实现线程间的同步和通信。

以下是常见的线程同步和通信的使用方式：

3.1 互斥锁

互斥锁用于保护共享资源的访问，以避免多个线程同时对共享资源进行修改导致数据一致性问题。

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

std::mutex mtx; // 互斥锁

void taskFunc(int taskId) {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Task " << taskId << " is running." << std::endl;
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(taskFunc, i);
    }
    for (std::thread& thread : threads) {
        thread.join();
    }
    return 0;
}

上述示例中，我们定义了一个 std::mutex 对象 mtx 作为互斥锁。在 taskFunc 函数中，我们使用 std::unique_lock 对互斥锁进行加锁，确保每次只有一个线程可以访问共享资源。

3.2 条件变量

条件变量用于线程间的等待和唤醒操作，允许一个线程等待某个条件成立后再继续执行。

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool flag = false; // 条件标志，初始为false

void taskFunc(int taskId) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return flag; }); // 等待条件变量满足
    std::cout << "Task " << taskId << " is running." << std::endl;
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(taskFunc, i);
    }

    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟等待2秒钟

    {
        std::unique_lock<std::mutex> lock(mtx);
        flag = true;
        cv.notify_all(); // 唤醒所有等待的线程
    }

    for (std::thread& thread : threads) {
        thread.join();
    }

    return 0;
}

上述示例中，我们在 main 函数中创建了10个线程，并在其中使用了条件变量。线程在执行时，会调用 cv.wait(lock, []{ return flag; }) 进行等待，直到条件变量 flag 的值为 true。在 main 函数中，我们等待2秒钟后将 flag 设置为 true，并通过调用 cv.notify_all() 唤醒所有等待的线程。

3.3 原子操作

原子操作被设计用于在多线程环境中进行共享变量的原子访问，保证操作的原子性，避免数据竞争和不确定行为。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void taskFunc() {
    for (int i = 0; i < 100000; ++i) {
        counter.fetch_add(1);
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(taskFunc);
    }
    for (std::thread& thread : threads) {
        thread.join();
    }

    std::cout << "Counter value: " << counter << std::endl;
    return 0;
}

上述示例中，我们使用 std::atomic 类型来定义一个原子变量 counter，并在每个线程中对其进行原子操作 fetch_add，实现对 counter 的安全访问。

4. 线程调度与优先级

C++标准库并没有提供直接的线程调度和优先级设置的接口，因此线程的调度和优先级通常依赖于操作系统的调度算法。

在某些特定的场景下，可以使用操作系统的相关接口来设置线程的调度策略和优先级。例如，对于Linux系统可以使用 pthread_setschedparam 函数来设置线程的调度参数。

#include <iostream>
#include <thread>
#include <sched.h>

void taskFunc() {
    std::cout << "Thread is running." << std::endl;
}

int main() {
    std::thread myThread(taskFunc);

    // 设置线程的调度参数为实时调度策略，优先级为最高（99）
    struct sched_param params;
    params.sched_priority = 99;
    int ret = pthread_setschedparam(myThread.native_handle(), SCHED_FIFO, &params);
    if (ret != 0) {
        std::cerr << "Failed to set thread scheduling: " << ret << std::endl;
    }

    myThread.join();
    return 0;
}

上述示例中，我们创建了一个名为 myThread 的线程，并使用 pthread_setschedparam 函数设置了线程的调度参数为实时调度策略（SCHED_FIFO），优先级最高（99）。

需要注意的是，线程调度和优先级的设置依赖于操作系统，代码的可移植性可能会受到影响。

总结

通过使用C++标准库提供的 std::thread 类以及一些同步机制如互斥锁、条件变量和原子操作，我们可以比较方便地管理多个线程的创建、销毁和调度。对于更复杂的场景，可以借助第三方库或操作系统提供的接口来进行线程池的管理、线程间的同步与通信、以及线程的调度与优先级设置。正确地管理多个线程的同时，也需要注意线程安全和避免数据竞争的问题。