优先队列 C++

Question

我在 C++ 中创建了以下优先级队列

priority_queue < ThreadInfo*, vector<ThreadInfo*>, CompareThread > thread_queue;

ThreadInfo 类在哪里

class ThreadInfo {
public:
    ThreadInfo();
    ThreadInfo(const ThreadInfo& orig);
    ThreadInfo(int thread_id,int init_time,int sleep_time,int run_time,int priority,int is_critical)
    {
        this->thread_id=thread_id;
        this->is_critical=is_critical;
        this->init_time=init_time;
        this->priority=priority;
        this->run_time=run_time;
        this->sleep_time=sleep_time;
    }

    void set_critical(bool value)
    {
        is_critical=value;
    }
    bool get_critical()
    {
        return is_critical;
    }
    void set_sleep_time(long value)
    {
        sleep_time=value;
    }

    long get_sleep_time(long value)
    {
        return sleep_time;
    }

    void set_run_time(long value)
    {
        sleep_time=value;
    }

    long get_run_time(long value)
    {
        return sleep_time;
    }
    int get_lock_type()
    {
        return lock_type;
    }
    void set_lock_type(int lock_type)
    {
        this->lock_type=lock_type;
    }

    int get_priority()
    {
        return priority;
    }
    void set_priority(int value)
    {
        this->priority=value;
    }

    unsigned long int get_thread_id()
    {
        return thread_id;
    }
    void set_thread_id(unsigned long int value)
    {
        this->thread_id=value;
    }
    virtual ~ThreadInfo();

private:
    unsigned long int thread_id;
    long init_time;
    long sleep_time;
    long run_time;
    int priority;
    bool is_critical;
    //1=spin,2=busy,3=semaphore
    int lock_type;



};

比较类是

class CompareThread {
public:
    bool operator()(ThreadInfo* th1, ThreadInfo* th2)
    {
       if (th1->get_priority()>th2->get_priority()) return true;

       return false;
    }
};

然后我在下面的函数中插入元素，

void ThreadScheduler::register_thread(ThreadInfo &th)
{

        thread_queue.push(&th);


}

我从下面的函数调用线程寄存器，

int ThreadController::thread_register(pthread_t &t, int priority, bool critical)
{
    ThreadInfo ti;
    cout<<"t reg:"<<t<<endl;
    ti.set_thread_id(t);
    ti.set_critical(critical);
    ti.set_priority(priority);
    ThreadScheduler::Instance()->register_thread(ti);
}

但是每次当我将一些线程信息对象推送到队列时，当我调用 thread_queue.top() 时，我都会得到最新的对象，它是否应该返回具有最低优先级的线程对象。这里有什么问题吗？

Answer 1

您正在将指向同一内存块的指针传递到队列中。您正在使用对本地对象的引用调用 register_thread 并将其地址排队。这就是他们都一样的原因。另一个问题是，当您离开thread_register 函数时，本地ti 将被删除（超出范围）并且您将在队列中没有有效条目。

你需要做的是为每个信息分配新的内存并将数据复制到这个内存中。因此，您插入队列的每个元素指针都必须来自不同的new，如果您有一个复制构造函数，则可以这样做：

void ThreadScheduler::register_thread(ThreadInfo &th)
{
        thread_queue.push(new ThreadInfo(th));
        /* ... */
}

检查这个：https://stackoverflow.com/a/986093/390913

Answer 2

问题是您使用的是指向在函数中本地声明的变量的指针。一旦函数 (ThreadController::thread_register) 完成，局部变量就不再存在，指针现在指向一些未分配的内存。

有两种解决方案：

1. 使用智能指针，如std::shared_ptr，并在ThreadController::thread_register中创建一个新指针：

   std::shared_ptr<ThreadInfo> ti(new ThreadInfo);
   

   当然你必须记住在其他地方也改成std::shared_ptr，并且使用->访问操作符而不是.。

2. 根本不使用指针，让类数据（非常简单）被复制。

我建议使用备选方案 2。