线程和线程池的向量C++

在C++中，线程和线程池向量能够帮助程序员编写更高效和可扩展的应用程序。线程向量可以提高应用程序的并发性和性能，而线程池向量可以更好地管理和利用系统资源。

简介

线程是操作系统在执行应用程序时调度的最小单位。多线程编程允许应用程序在单个进程内并发执行，从而提高并发性和性能。C++11引入了标准化的线程库，可以有效地创建和管理线程。

线程池是一种预先分配和管理一组线程的机制，可以避免线程频繁创建和销毁的开销。线程池管理线程的生命周期，从而更好地利用计算机资源并提高性能。

向量是一种C++中可变长度数组的数据类型，可以在不明确指定数组大小的情况下扩展。向量可以存储任意类型的数据，包括线程和线程池。

使用线程向量

C++线程向量通常用来并发执行一组任务。以下是一些常见的用法：

创建和启动线程

创建和启动线程的方法非常简单。通过std::thread类创建线程实例，然后调用线程实例的join()函数等待线程执行完毕。

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

void threadFunc(int i)
{
    std::cout << "Thread " << i << " started" << std::endl;
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::thread> threads;
    int numThreads = 4;

    for (int i = 0; i < numThreads; i++)
    {
        threads.push_back(std::thread(threadFunc, i));
    }

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

    return 0;
}

等待所有线程完成

对于一组任务，我们可能需要等待所有线程完成后再执行下一步。可以使用std::thread::joinable()函数和std::thread::join()函数来实现该操作。

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

void threadFunc(int i)
{
    std::cout << "Thread " << i << " started" << std::endl;
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::thread> threads;
    int numThreads = 4;

    for (int i = 0; i < numThreads; i++)
    {
        threads.push_back(std::thread(threadFunc, i));
    }

    // wait for all threads to complete
    for (auto& t : threads)
    {
        if (t.joinable())
            t.join();
    }

    return 0;
}

限制线程数量

有时候，我们需要限制线程数量。这时，可以使用信号量或互斥量来限制并发执行的线程数量。

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

std::mutex g_mtx;

void threadFunc(int i, int n)
{
    std::cout << "Thread " << i << " started" << std::endl;
    {
        std::lock_guard<std::mutex> lock(g_mtx);
        std::cout << "Thread " << i << " executing" << std::endl;
    }
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::thread> threads;
    int numThreads = 4;

    for (int i = 0; i < numThreads; i++)
    {
        threads.push_back(std::thread(threadFunc, i, numThreads));
    }

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

    return 0;
}

使用线程池向量

C++线程池向量可以很容易地管理线程。以下是一些常见的用法：

创建和启动线程池

创建和启动线程池的方法非常简单。通过调用std::async()函数创建线程实例，然后将其放入线程池中。

#include <iostream>
#include <vector>
#include <future>

void threadFunc(int i)
{
    std::cout << "Thread " << i << " started" << std::endl;
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::future<void>> futures;
    int numThreads = 4;

    for (int i = 0; i < numThreads; i++)
    {
        auto fut = std::async(std::launch::async, threadFunc, i);
        futures.push_back(std::move(fut));
    }

    // wait for all threads to complete
    for (auto& f : futures)
    {
        f.wait();
    }

    return 0;
}

等待所有线程完成

对于一组任务，我们可能需要等待所有线程完成后再执行下一步。可以使用std::future::valid()函数和std::future::wait()函数来实现该操作。

#include <iostream>
#include <vector>
#include <future>

void threadFunc(int i)
{
    std::cout << "Thread " << i << " started" << std::endl;
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::future<void>> futures;
    int numThreads = 4;

    for (int i = 0; i < numThreads; i++)
    {
        auto fut = std::async(std::launch::async, threadFunc, i);
        futures.push_back(std::move(fut));
    }

    // wait for all threads to complete
    while (!futures.empty())
    {
        auto it = futures.begin();
        while (it != futures.end())
        {
            if (it->valid() && it->wait_for(std::chrono::milliseconds(0)) == std::future_status::ready)
                it = futures.erase(it);
            else
                ++it;
        }
    }

    return 0;
}

限制线程数量

线程池向量可以很容易地限制并发执行的线程数量。只需使用有限的线程池大小调用std::async()函数即可。

#include <iostream>
#include <vector>
#include <future>

void threadFunc(int i)
{
    std::cout << "Thread " << i << " started" << std::endl;
    // do some work
    std::cout << "Thread " << i << " ended" << std::endl;
}

int main()
{
    std::vector<std::future<void>> futures;
    int numThreads = 4;
    int maxThreads = 2; // maximum number of concurrent threads

    for (int i = 0; i < numThreads; i++)
    {
        if (i >= maxThreads && !futures.empty())
        {
            auto& fut = futures.front();
            if (fut.valid())
            {
                fut.wait();
                futures.erase(futures.begin());
            }
        }

        auto fut = std::async(std::launch::async, threadFunc, i);
        futures.push_back(std::move(fut));
    }

    // wait for all threads to complete
    while (!futures.empty())
    {
        auto it = futures.begin();
        while (it != futures.end())
        {
            if (it->valid() && it->wait_for(std::chrono::milliseconds(0)) == std::future_status::ready)
                it = futures.erase(it);
            else
                ++it;
        }
    }

    return 0;
}

总结

C++线程和线程池向量是高效、可扩展和跨平台的多线程编程机制。线程向量可以实现并发执行一组任务，而线程池向量可以更好地利用系统资源并提高性能。无论您是开发桌面应用程序还是大型服务器，使用这些机制都将帮助您编写更高效和可维护的应用程序。