執行緒池未完成所有任務

我之前問過這個問題的一個更簡單的版本并得到了正確的答案：執行緒池不能處理大量任務 現在我正在嘗試使用執行緒池從類的物件并行運行任務。我的任務很簡單，只為該類實體列印一個數字。我期待數字 0->9 被列印，但我得到的一些數字被列印不止一次，而一些數字根本沒有列印。誰能看到我在回圈中創建任務時做錯了什么？

#include "iostream"
#include "ThreadPool.h"
#include <chrono>
#include <thread>

using namespace std;
using namespace dynamicThreadPool;

class test {
    int x;
public:
    test(int x_in) : x(x_in) {}
    void task()
    {
        cout << x << endl;
    }
};

int main(void)
{
    thread_pool pool;
    for (int i = 0; i < 10; i  )
    {
        test* myTest = new test(i);
        std::function<void()> myFunction = [&] {myTest->task(); };
        pool.submit(myFunction);
    }
    while (!pool.isQueueEmpty())
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        cout << "waiting for tasks to complete" << endl;
    }

    return 0;
}

這是我的執行緒池，我從“C Concurrency in Action”一書中得到了這個定義：

#pragma once
#include <queue>
#include <future>
#include <list>
#include <functional>
#include <memory>

template<typename T>
class threadsafe_queue
{
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    threadsafe_queue() {}
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(std::move(new_value));
        data_cond.notify_one();
    }
    void wait_and_pop(T& value)
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this] {return !data_queue.empty(); });
        value = std::move(data_queue.front());
        data_queue.pop();
    }
    bool try_pop(T& value)
    {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return false;
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

class join_threads
{
    std::vector<std::thread>& threads;
public:
    explicit join_threads(std::vector<std::thread>& threads_) : threads(threads_) {}
    ~join_threads()
    {
        for (unsigned long i = 0; i < threads.size(); i  )
        {
            if (threads[i].joinable())
            {
                threads[i].join();
            }
        }
    }
};

class thread_pool
{
    std::atomic_bool done;
    threadsafe_queue<std::function<void()> > work_queue;
    std::vector<std::thread> threads;
    join_threads joiner;
    void worker_thread()
    {
        while (!done)
        {
            std::function<void()> task;
            if (work_queue.try_pop(task))
            {
                task();
            }
            else
            {
                std::this_thread::yield();
            }
        }
    }
public:
    thread_pool() : done(false), joiner(threads)
    {
        unsigned const thread_count = std::thread::hardware_concurrency();
        try
        {
            for (unsigned i = 0; i < thread_count; i  )
            {
                threads.push_back(std::thread(&thread_pool::worker_thread, this));
            }
        }
        catch (...)
        {
            done = true;
            throw;
        }
    }
    ~thread_pool()
    {
        done = true;
    }
    template<typename FunctionType>
    void submit(FunctionType f)
    {
        work_queue.push(std::function<void()>(f));
    }
    bool isQueueEmpty()
    {
        return work_queue.empty();
    }
};

uj5u.com熱心網友回復：

有太多代碼需要分析所有這些，但您可以在此處通過參考獲取指標：

{
    test* myTest = new test(i);
    std::function<void()> myFunction = [&] {myTest->task(); };
    pool.submit(myFunction);
} // pointer goes out of scope

在該指標超出范圍后，如果您稍后這樣做，您將有未定義的行為myTest->task();。

要解決這個緊迫的問題，請delete在之后復制指標和物件以防止記憶體泄漏：

{
    test* myTest = new test(i);
    std::function<void()> myFunction = [=] {myTest->task(); delete myTest; };
    pool.submit(myFunction);
}

我懷疑這可以在不使用的情況下解決new，但我會把它留給你。

標籤：C 多线程 指针 本国的

上一篇：Python時間頻率中的執行緒優先級

下一篇：Codeigniter4如何在視圖中呼叫控制器方法？