HarmonyOS taskpool使用crash

#00 pc 0000000000185ca8 /system/lib/ld-musl-aarch64.so.1(raise+188)
#01 pc 00000000001381a8 /system/lib/ld-musl-aarch64.so.1(abort+20)
#02 pc 00000000000169c8 /system/lib64/platformsdk/libuv.so(uv__io_poll+336)
#03 pc 0000000000017728 /system/lib64/platformsdk/libuv.so(uv_run+376)
#04 pc 000000000001c164 /system/lib64/module/libtaskpool.z.so(Commonlibrary::Concurrent::TaskPoolModule::Worker::ExecuteInThread(void const*)+376)
#05 pc 0000000000019b54 /system/lib64/module/libtaskpool.z.so(Commonlibrary::Concurrent::TaskPoolModule::TaskRunner::TaskInnerRunner::Run()+68)

#include <iostream>
#include <stdexcept>

void SafeTask() {
    try {
        // 任务逻辑
        // ...

        throw std::runtime_error("Something went wrong");
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // 处理异常
    }
}

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

class SafeTaskPool {
public:
    SafeTaskPool(size_t numThreads);
    ~SafeTaskPool();

    void EnqueueTask(std::function<void()> task);

private:
    void WorkerThread();

    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex mutex_;
    std::condition_variable condition_;
    bool stop_;
};

SafeTaskPool::SafeTaskPool(size_t numThreads) : stop_(false) {
    for (size_t i = 0; i < numThreads; ++i) {
        workers_.emplace_back(&SafeTaskPool::WorkerThread, this);
    }
}

SafeTaskPool::~SafeTaskPool() {
    {
        std::unique_lock<std::mutex> lock(mutex_);
        stop_ = true;
    }
    condition_.notify_all();
    for (std::thread& worker : workers_) {
        worker.join();
    }
}

void SafeTaskPool::EnqueueTask(std::function<void()> task) {
    {
        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.push(std::move(task));
    }
    condition_.notify_one();
}

void SafeTaskPool::WorkerThread() {
    while (true) {
        std::function<void()> task;
        {
            std::unique_lock<std::mutex> lock(mutex_);
            condition_.wait(lock, [this] { return stop_ || !tasks_.empty(); });

            if (stop_ && tasks_.empty()) {
                return;
            }

            task = std::move(tasks_.front());
            tasks_.pop();
        }
        try {
            task();
        } catch (const std::exception& e) {
            std::cerr << "Task threw an exception: " << e.what() << std::endl;
        } catch (...) {
            std::cerr << "Task threw an unknown exception" << std::endl;
        }
    }
}

// 使用示例
int main() {
    SafeTaskPool pool(4);

    pool.EnqueueTask([] {
        std::cout << "Task 1" << std::endl;
    });

    pool.EnqueueTask([] {
        std::cout << "Task 2" << std::endl;
        throw std::runtime_error("Error in Task 2");
    });

    pool.EnqueueTask([] {
        std::cout << "Task 3" << std::endl;
    });

    std::this_thread::sleep_for(std::chrono::seconds(2));

    return 0;
}