C++ Session management methods - c++

Question

I want to create a session management scheme that , in few words , has to be this way:
A std::map to keep track of the current active sessions (filled up
with id string and and an associated message queue)
A set of threads on each message queue.
There are two ways to create this scheme:
Keep all the components in the main program and when needed fill up the map with a new session id and associated message queue and start a new detached thread with a reference to the queue that he will be polling on as argument.
//main program code
_session_map[id] = queue;
thread = new thread(&queue);
thread.detach();
thread.start();
//main program code
Create a session_manager class that hides all those mechanisms
to the main program.
class session_manager
{
//session_manager code
std::string new_session(std::string id)
{
_session_map[id] = queue;
thread = new thread(&queue);
thread.detach();
thread.start();
}
private:
std::map<std::string,message_queue> _session_map;
};
what is the better way to create this scheme? I'm not sure if the second scheme could work correctly because I'm not so expert on using threads.
Also I don't have a good idea on how to keep track of the closed sessions does anyone hve some suggestion?

Answer 1

A few years back I would have given an entirely different answer than I will do now.
I am also not sure what you mean with "session management" or how the queues relate to the workers. So I will start with a bit of assuming:
You want N threads to do work in parallel, competing with each other over jobs found in a queue.
Your session is kind of a working session, which is to last until the sequence of jobs is done.
In the older days of C++ thread-programming, I would have actually outlined architectures on how one can implement such a scheme.
But I suspect, that you only need a job getting done and not some "theory class".
So, instead of fiddling with low level threads (which are OS specific), I chose to showcase an (also OS specific) more abstract way to get things done.
Advantages:
Concurrent programming without having to deal with locks, mutexes, static thread functions calling pthis->Execute() etc.
Conceptually easy to understand. Message blocks, Sources, targets, messages, Worker objects (Actors/Agents). No promise-future C++-linq reactive functional programming replacement attempts (attempt on humor!).
Appears to come pretty close to what you have in mind.
Disadvantages:
Hides all the low level stuff us oldies are so proud of knowing and spent years of pure joy and despair with.
Runs only on Windows platforms (AFAIK), unfortunately.
All this code here uses the Windows Concurrency runtime.
#include "stdafx.h"
#include <thread>
#include <concrt.h>
#include <agents.h>
#include <iostream>
template<class _Job>
class Worker
: public concurrency::agent
{
concurrency::ISource<_Job> *m_source;
volatile bool m_running;
uint32_t m_counter;
public:
Worker(concurrency::ISource<_Job> *source)
: m_source(source)
, m_running(true)
, m_counter(0UL)
{}
~Worker()
{}
uint32_t Counter() const
{
return m_counter;
}
void Stop()
{
m_running = false;
}
virtual void run()
{
while (m_running)
{
try
{
_Job job = concurrency::receive(m_source, 1000);
m_counter++;
}
catch (concurrency::operation_timed_out& /*timeout*/)
{
std::cout << "Timeout." << std::endl;
}
}
_Job job;
while (concurrency::try_receive(m_source, job))
{
m_counter++;
}
done();
}
};
typedef uint64_t Job_t;
int _tmain(int argc, _TCHAR* argv[])
{
const size_t NUM_WORKERS = 4;
concurrency::unbounded_buffer<Job_t> buffer;
Worker<Job_t> workers[NUM_WORKERS] =
{ Worker<Job_t>(&buffer)
, Worker<Job_t>(&buffer)
, Worker<Job_t>(&buffer)
, Worker<Job_t>(&buffer)
};
std::vector<concurrency::agent*> agents;
for (auto& worker : workers)
{
agents.push_back(&worker);
worker.start();
}
for (uint64_t jobid = 0ULL; jobid < 1000000ULL; jobid++)
{
concurrency::asend(buffer, jobid);
}
for (auto& worker : workers)
{
worker.Stop();
}
concurrency::agent::wait_for_all(NUM_WORKERS,&agents[0]);
for (auto& worker : workers)
{
std::cout << "counter: " << worker.Counter() << std::endl;
}
return 0;
}