wrote:
> As a part of a TCP/IP server I want to split up the incoming socket
> requests from the work queue.
> To do this I have one thread which figures out which sockets are
> pending to be queried and another set of workerthreads which actually
> does this work.
>
> So far I've used std::list as a means of pushing a request from the
> socket thread to the worker threads.
> Each worker thread would then look every 10 ms to see if there is a
> job in the queue.
>
> Now I'm facing a problem though as there can be more requests of the
> same job coming from the socket thread.
> This has lead to concurrency problems when closing sockets (e.g. one
> worker thread detects the socket is done communicating and next one
> believes there is still action to perform).
>
> Therefore I want to remove duplicates when adding jobs to the work
> queue.
> So I'm looking for a replacement container which will tell me rather
> fast if a key element already exists and if preferedly still have this
> FIFO behavior of std::list.
> It's not unusual that there can be several thousands (e.g. up to
> 10000) objects in the worker queue.
>
> Should I aim for anything better than std::list? The only thing list
> won't give me is fast duplicate handling.
What if you split the job of keeping the order and preventing duplicates
between, say, std::list and std::set? Let your std::set store the
iterators to the std::list of objects. Make sure the comparator for
the std::set is implemented properly (it can be tricky since the functor
isn't returning the [in]equality but rather the less-than relationship).
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Similar Threads
