选择STL容器来存储线程

Question

I am trying to choose the best STL container to hold Thread objects (I am writing a thread library). My problem is that I'm not very familiar with any of them, and while reading the api helps, I would like to consult someone who had used it before.

Anyway - every Thread object has two important attributes: _id and _priority . I need to be able to access a thread by _id , so I naturally thought of a hash_map. I also want the objects to be sorted by _priority (different Thread objects can have the same priority), so I thought of a priority queue with pointers to the hash_map, but if I delete a thread who's not first on the queue it gets a little ugly.

Is there a better solution? Thanks!

Answer 1

To get two types of access you either need to combine two containers... or reuse a library that combines containers for you.

Boost.MultiIndex was invented for precisely this kind of needs.

The basics page shows an example that has employees accessible by id (unique) and sorted by name (non-unique), which is pretty much what you are going for.

The key extractors are perhaps not obvious. Supposing that your thread ressemble:

class Thread {
public:
    std::size_t id() const;
    std::size_t priority() const;

    ...
};

You should be able to write:

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/const_mem_fun.hpp>
#include <boost/multi_index/member.hpp>

// define a multiply indexed set with indices by id and name
typedef multi_index_container<
    Thread,
    indexed_by<
        ordered_unique<
            const_mem_fun<Thread, std::size_t, &Thread::id>
        >,
        ordered_non_unique<
            const_mem_fun<Thread, std::size_t, &Thread::priority>
        >
    > 
> ThreadContainer;

Which defines a container of thread uniquely identified by their id() and sorted according to their priority() .

I encourage you to play around with the various indexes. Also, if you provide friend access to your class or specific getters that return mutable references, then using mem_fun instead of const_mem_fun you will be able to update your objects in place (for example, change their priority).

It's a very complete (if daunting) library.

Answer 2

Best solution is possibly std::map ,, providing you a key / value pair. In your scenario the key has the type of your _id and the value the type Thread (assuming this is the name of your class). By copying all values to a std::vector you can sort by _priority with std::sort and a predicate.

Answer 3

一个简单的解决方案是保持std::unordered_map提供密钥 - >线程查找，然后使用std::set来实现优先级队列。