Question

我创建了一个线程池，用于在4个线程之间分配100个计算。

我无法理解为什么以下代码在4次计算后卡住了。在每次计算之后，必须释放线程，并且我期望.joinable()返回false，因此程序将继续。

结果：

[[[01] calculated 
] calculated 
2] calculated 
[3] calculated

代码：

#include <string>
#include <iostream>
#include <vector>
#include <thread>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread/thread.hpp>
#include <cmath>

class AClass
{
public:

    void calculation_single(std::vector<double> *s,int index)
    {
        (*s)[index]=sin(double(index));
        std::cout<<"["<<index<<"] calculated \n";
    }

    void calculation()
    {
        const uint N_nums=100;
        const uint N_threads=4;
        std::vector<double> A;
        A.assign(N_nums,0.0);
        std::vector<std::thread> thread_pool;
        for(uint i=0;i<N_threads;i++)
            thread_pool.push_back(std::thread());

        uint A_index=0;
        while(A_index<N_nums)
        {
            int free_thread=-1;
            for(uint i=0;i<N_threads && free_thread<0;i++)
                if(!thread_pool[i].joinable())
                    free_thread=i;
            if(free_thread>-1)
            {
                thread_pool[free_thread]=
                    std::thread(
                        &AClass::calculation_single,
                        this,
                        &A,
                        int(A_index));
                A_index++;
            }
            else
            {
                boost::this_thread::sleep(boost::posix_time::milliseconds(1));
            }

        }

        // wait for tasks to finish
        for(std::thread& th : thread_pool)
            th.join();
    }

};

int main()
{
    AClass obj;
    obj.calculation();
    return 0;
}

Answer 1

如果一个线程基本上不是空的，那么它是可连接的。

具有已完成任务的线程不为空。

std::thread bob;

bob无法加入。

你的主题是。你没有做任何事使他们无法加入。

此外，忙碌的等待是一个糟糕的线程池。

创建一个使用者生成器队列，其中包含一个消耗任务的线程池和一个中止方法。通过打包任务将任务输入队列并返回std::future<T>。不要为每个任务生成一个新线程。

线程池卡住了

1 个答案: