server1/Server/ThreadManager/ThreadManager.cpp

#include "ThreadManager.h"

#include "CreateWAVThread.h"
#include "CreateDBThread.h"

#include "CalculateDBThread.h"
#include "ConsistencyCompareThread.h"
#include "GlobalVariable.h"
#include "NoiseDetectThread.h"
#include "RtpOneRoadThread.h"

#include "ThreadPool.h"
#include <mutex>

ThreadManager::ThreadManager()
{
    m_logger = spdlog::get("ACAServer");
    if(m_logger == nullptr)
    {
        fmt::print("ThreadManager: ACAServer Logger not found.\n");
        return;
    }
    m_logBase = "ThreadManager";
}

/* 启动所有线程 */
// void ThreadManager::startAllThreads()
// {

// }

/* 停止所有线程 */
void ThreadManager::stopAllThreads()
{

}

/* 创建一个录音通道及其附属的线程 */
bool ThreadManager::createRecordThread(const SoundCardRoadInfo_t& roadInfo)
{
    /* 需要修改的地方
        1、录音线程修改线程函数，添加task()函数，统一处理开启和关闭状态
        2、原始录音线程，获取分派数据的函数指针不再自己获取，而是由分派线程自己设置过来指针
        3、给存储录音线程的队列添加互斥锁，保护线程的创建和销毁
     */
    
    /* 先查找队列中有没有该录音通道 */

    return true;
}

/* 销毁一个录音通道及其附属的线程 */
bool ThreadManager::destroyRecordThread(const SoundCardRoadInfo_t& roadInfo)
{

    return true;
}



/* 查找录音线程 */
BaseRecordThread* ThreadManager::findRecordThread(EThreadType type, int cardID, int recordID)
{
    switch(type)
    {
        case EThreadType::Type_RecordSrc:           /* 录音线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexRecordThreads);
                for (auto& pThread : m_recordThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID &&
                        pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        case EThreadType::Type_CreateWAV:           /* 创建wav小文件和分离左右声道的线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexCreateWAVThreads);
                for (auto& pThread : m_createWAVThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
                        pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        case EThreadType::Type_CalculateDBAndPhase:      /* 计算音量和反相的线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexCreateDBThreads);
                for (auto& pThread : m_createDBThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
                        pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        case EThreadType::Type_CreateLongWAV:           /* 创建长文件的线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexCreateLongWAVThreads);
                for (auto& pThread : m_createLongWAVThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
                        pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        case EThreadType::Type_AssignSrcData:           /* 分派数据线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexAssignSrcDataThreads);
                for (auto& pThread : m_assignSrcDataThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
                        pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        case EThreadType::Type_RtpSend:               /* RTP发送线程 */
            {
                std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
                for (auto& pThread : m_rtpSendThreads)
                {
                    if (pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
                        pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
                    {
                        return pThread;
                    }
                }
            }
            break;
        default:
            SPDLOG_LOGGER_ERROR(m_logger, "{} 查找录音线程失败，未知线程类型: {}", m_logBase, static_cast<int>(type));
            return nullptr; // 未知线程类型
    }
    
    
    return nullptr;
}


/* 获取创建WAV线程指针 */
CreateWAVThread* ThreadManager::getCreateWAVThread(int cardID, int recordID)
{
    std::lock_guard<std::mutex> lock(m_mutexCreateWAVThreads);
    for(auto& pThread : m_createWAVThreads)
    {
        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
        {
            return dynamic_cast<CreateWAVThread*>(pThread);
        }
    }
    return nullptr;
}

/* 获取创建音量值的线程 */
CreateDBThread* ThreadManager::getCreateDBThread(int cardID, int recordID)
{
    std::lock_guard<std::mutex> lock(m_mutexCreateDBThreads);
    for(auto& pThread : m_createDBThreads)
    {
        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
        {
            return dynamic_cast<CreateDBThread*>(pThread);
        }
    }
    return nullptr;
}

/* 获取发送Rtp数据的线程 */
RTPOneRoadThread* ThreadManager::getRtpSendThread(int cardID, int recordID)
{
    std::lock_guard<std::mutex> lock(m_mutexRtpSendThreads);
    for(auto& pThread : m_rtpSendThreads)
    {
        if(pThread->getThreadInfo().cardRoadInfo.nSoundCardNum == cardID &&
           pThread->getThreadInfo().cardRoadInfo.roadInfo.nRoadNum == recordID)
        {
            return dynamic_cast<RTPOneRoadThread*>(pThread);
        }
    }
    return nullptr;
}


/* -------------------------------------------------------------------------------------------
 * 获取计算线程，如果该线程不存在则创建该线程
 * 当不需要此线程后，调用remove()函数去掉该线程
 * -------------------------------------------------------------------------------------------- */

/* 获取一致性比对线程，线程不存在则创建 */
ConsistencyCompareThread* ThreadManager::getConsistencyCompareThread(const SoundCardRoadInfo_t& roadInfo1, const SoundCardRoadInfo_t& roadInfo2)
{
    std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
    for(const auto pThread : m_listConsistencyCompareThreads)
    {
        if(pThread->isRoadEqual(roadInfo1, roadInfo2))
        {
            return pThread; // 找到相同的线程，直接返回
        }
    }
    /* 没找到该线程，创建新的线程 */
    CompareItemRoadInfo_t item1;
    item1.nCompareRoadNum = 1;
    item1.scRoadInfo = roadInfo1;
    CompareItemRoadInfo_t item2;
    item2.nCompareRoadNum = 2;
    item2.scRoadInfo = roadInfo2;

    CalculateThreadInfo_t threadInfo;
    threadInfo.compareItemInfo.mapRoad.insert(item1.nCompareRoadNum, item1);
    threadInfo.compareItemInfo.mapRoad.insert(item2.nCompareRoadNum, item2);
    ConsistencyCompareThread* newThread = new ConsistencyCompareThread(threadInfo);
    
    if(newThread == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "创建一致性比对线程失败");
        return nullptr; // 创建失败
    }
    CPPTP.add_task(&ConsistencyCompareThread::threadTask, newThread);

    m_listConsistencyCompareThreads.push_back(newThread);
    m_referCountConsistencyCompare++; // 引用计数加一

    return newThread;
}

/* 去掉线程，线程使用的计数减一，计数为0则销毁该线程 */
bool ThreadManager::removeConsistencyCompareThread(SoundCardRoadInfo_t& roadInfo1, SoundCardRoadInfo_t& roadInfo2)
{
    std::lock_guard<std::mutex> lock(m_mutexConsistencyCompareThreads);
    ConsistencyCompareThread* pThreadToRemove = nullptr;
    for(const auto pThread : m_listConsistencyCompareThreads)
    {
        if(pThread->isRoadEqual(roadInfo1, roadInfo2))
        {
            pThreadToRemove = pThread; // 找到相同的线程，直接返回
            break;
        }
    }
    if(pThreadToRemove == nullptr)
    {
        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程未找到", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
        return false; // 没找到该线程
    }
    m_referCountConsistencyCompare--; // 引用计数减一
    if(m_referCountConsistencyCompare <= 0)
    {
        /* 停止线程，并一直等待其停止 */
        pThreadToRemove->stopThreadBlock();
        m_listConsistencyCompareThreads.remove(pThreadToRemove); // 从列表中移除
        delete pThreadToRemove; // 删除线程
        pThreadToRemove = nullptr;
        m_referCountConsistencyCompare = 0; // 重置引用计数
        SPDLOG_LOGGER_WARN(m_logger, "{}:{} - {}:{} 一致性比对线程已销毁", roadInfo1.strSoundCardName.toStdString(), roadInfo1.roadInfo.nRoadNum,
            roadInfo2.strSoundCardName.toStdString(), roadInfo2.roadInfo.nRoadNum);
    }

    return true;
}

/* 获取噪音检测线程 */
NoiseDetectThread* ThreadManager::getNoiseDetectThread(const SoundCardRoadInfo_t& roadInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexNoiseDetectThreads);
    for(const auto pThread : m_listNoiseDetectThreads)
    {
        const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
        if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
           threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
        {
            return pThread; // 找到相同的线程，直接返回
        }
    }
    /* 没找到该线程，创建新的线程 */
    CalculateThreadInfo_t threadInfo;
    CompareItemRoadInfo_t item;
    item.nCompareRoadNum = 1; // 假设噪音检测线程
    item.scRoadInfo = roadInfo;
    threadInfo.compareItemInfo.mapRoad.insert(item.nCompareRoadNum, item);
    NoiseDetectThread* newThread = new NoiseDetectThread(threadInfo);
    if(newThread == nullptr)
    {
        SPDLOG_LOGGER_ERROR(m_logger, "创建噪音检测线程失败");
        return nullptr; // 创建失败
    }
    CPPTP.add_task(&NoiseDetectThread::threadTask, newThread);
    m_listNoiseDetectThreads.push_back(newThread);
    m_referCountNoiseDetect++; // 引用计数加一

    return newThread;
}

/* 去掉噪音检测线程，线程使用的计数减一，计数为0则销毁该线程 */
bool ThreadManager::removeNoiseDetectThread(SoundCardRoadInfo_t& roadInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexNoiseDetectThreads);
    NoiseDetectThread* pThreadToRemove = nullptr;
    for(const auto pThread : m_listNoiseDetectThreads)
    {
        const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
        if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
           threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
        {
            pThreadToRemove = pThread; // 找到相同的线程，直接返回
            break;
        }
    }
    if(pThreadToRemove == nullptr)
    {
        SPDLOG_LOGGER_WARN(m_logger, "{}:{} 噪音检测线程未找到", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
        return false; // 没找到该线程
    }
    m_referCountNoiseDetect--; // 引用计数减一
    if(m_referCountNoiseDetect <= 0)
    {
        pThreadToRemove->stopThreadBlock(); // 停止线程
        m_listNoiseDetectThreads.remove(pThreadToRemove); // 从列表中移除
        delete pThreadToRemove; // 删除线程
        pThreadToRemove = nullptr;
        m_referCountNoiseDetect = 0; // 重置引用计数
        SPDLOG_LOGGER_INFO(m_logger, "{}:{} 噪音检测线程已销毁", roadInfo.strSoundCardName.toStdString(), roadInfo.roadInfo.nRoadNum);
    }

    return true;
}

// /* 获取音量报警线程 */
// CalculateDBPhaseThread* ThreadManager::getCalculateDBPhaseThread(const SoundCardRoadInfo_t& roadInfo)
// {
//     std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
//     for(const auto pThread : m_listCalculateDBPhaseThreads)
//     {
//         const SoundCardRoadInfo_t& threadRoadInfo = pThread->getRoadInfo();
//         if(threadRoadInfo.nSoundCardNum == roadInfo.nSoundCardNum &&
//            threadRoadInfo.roadInfo.nRoadNum == roadInfo.roadInfo.nRoadNum)
//         {
//             return pThread; // 找到相同的线程，直接返回
//         }
//     }
        
//     /* 没找到该线程，创建新的线程 */
//     CompareItemRoadInfo_t item;
//     item.nCompareRoadNum = 1; // 假设音量报警线程
//     item.scRoadInfo = roadInfo;
    
//     threadInfo.compareItemInfo.mapRoad.insert(item.nCompareRoadNum, item);
//     CalculateDBPhaseThread* newThread = new CalculateDBPhaseThread(threadInfo);
    
//     if(newThread == nullptr)
//     {
//         SPDLOG_LOGGER_ERROR(m_logger, "创建音量报警线程失败");
//         return nullptr; // 创建失败
//     }
//     CPPTP.add_task(&CalculateDBPhaseThread::threadTask, newThread);

//     m_listCalculateDBPhaseThreads.push_back(newThread);
//     m_referCountCalculateDBPhase++; // 引用计数加一

//     return newThread;
// }

// /* 去掉音量报警线程，线程使用的计数减一，计数为0则销毁该线程 */
// bool ThreadManager::removeCalculateDBPhaseThread(RoadNumberInfo_t& roadInfo)
// {
//     std::lock_guard<std::mutex> lock(m_mutexCalculateDBPhaseThreads);
//     CalculateDBPhaseThread* pThreadToRemove = nullptr;
//     for(const auto pThread : m_listCalculateDBPhaseThreads)
//     {
//         if(pThread->getRoadInfo().roadID == roadInfo.roadID)
//         {
//             pThreadToRemove = pThread; // 找到相同的线程，直接返回
//             break;
//         }
//     }
//     if(pThreadToRemove == nullptr)
//     {
//         SPDLOG_LOGGER_WARN(m_logger, "{} 音量报警线程未找到", roadInfo.strRoadName);
//         return false; // 没找到该线程
//     }
//     m_referCountCalculateDBPhase--; // 引用计数减一
//     if(m_referCountCalculateDBPhase <= 0)
//     {
//         pThreadToRemove->stopThread(); // 停止线程
//         m_listCalculateDBPhaseThreads.remove(pThreadToRemove); // 从列表中移除
//         delete pThreadToRemove; // 删除线程
//         pThreadToRemove = nullptr;
//         m_referCountCalculateDBPhase = 0; // 重置引用计数
//         SPDLOG_LOGGER_INFO(m_logger, "{} 音量报警线程已销毁", roadInfo.strRoadName);
//     }

//     return true;
// }