C++ C++；会话管理方法

我想创建一个会话管理方案，简而言之，它必须是这样的：

• 用于跟踪当前活动会话（已填充）的std:：map 带有id字符串和关联的消息队列）
• 每个消息队列上的一组线程

创建此方案有两种方法：

将所有组件保留在主程序中，并在需要时使用新的会话id和关联的消息队列填充映射，然后启动一个新的分离线程，引用他将作为参数轮询的队列

 //main program code
   _session_map[id] = queue;
   thread = new thread(&queue);
   thread.detach();
   thread.start();
 //main program code

创建一个会话管理器类，隐藏所有这些机制 到主程序

 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;
 };

class session\u管理器
{
//会话管理器代码
std:：string新建会话（std:：string id）
{
_会话映射[id]=队列；
线程=新线程（&队列）；
thread.detach（）；
thread.start（）；
}
私人：
std:：map _session_map；
};

创建此方案的更好方法是什么？我不确定第二个方案是否能正常工作，因为我不太擅长使用线程。

---

另外，我也不知道如何跟踪闭门会议。有人有什么建议吗？

几年前，我会给出一个与现在完全不同的答案

我也不知道你所说的“会话管理”是什么意思，也不知道队列与工人的关系。因此，我将从一点假设开始：

• 您希望N个线程并行工作，相互竞争队列中的作业
• 您的会话是一种工作会话，它将持续到作业序列完成为止

在C++线程编程的老年代，我实际上已经概述了如何实现这样一个方案的架构。 但我怀疑，你只需要完成一项工作，而不需要什么“理论课”

因此，我选择展示一种（也是特定于操作系统的）更抽象的方式来完成任务，而不是摆弄低级线程（特定于操作系统）

优点：

• 无需处理锁、互斥锁、调用

  pthis->Execute（）的静态线程函数等的并发编程

• 概念上容易理解。消息块、源、目标、消息、工作对象（参与者/代理）。没有承诺未来的C++-linq反应式函数编程替换尝试（尝试幽默！）
• 看起来很接近你的想法

缺点：

• 隐藏了所有我们这些老一辈人为知道这些而自豪的低级东西，并与它们一起度过了纯粹的快乐和绝望的岁月
• 不幸的是，它只在Windows平台（AFAIK）上运行

这里的所有代码都使用Windows并发运行时

#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;
}

#包括“stdafx.h”
#包括
#包括
#包括
#包括
模板
班主任
：公共并发：：代理
{
并发：：ISource*m_源；
不稳定的bool-m_运行；
uint32μtμu计数器；
公众：
辅助程序（并发：：ISource*源）
：m_源（源）
，m_正在运行（真）
，m_计数器（0UL）
{}
~Worker（）
{}
uint32\u t计数器（）常数
{
返回m_计数器；
}
无效停止（）
{
m_running=假；
}
虚拟空运行（）
{
同时（m_运行）
{
尝试
{
_Job Job=concurrency:：receive（m_source，1000）；
m_计数器++；
}
捕获（并发：：操作超时&/*超时*/）
{
std:：cout“每个消息队列上的一组线程”是什么意思？这组线程侦听队列？或写入队列？或相互通信？线程从队列中提取消息并进行处理。不需要写入队列或与线程通信。