[C++ 성능 최적화 및 고급 테크닉] Day 29: 프로젝트: 실시간 데이터 처리 시스템 개발 (3)

프로젝트 목표

이번 단계에서는 실시간 데이터 처리 시스템의 성능을 더욱 향상시키고, 시스템의 모니터링 및 관리 기능을 추가하여 전체적인 완성도를 높입니다. 특히, 다음과 같은 부분을 다룹니다:

1. 성능 향상: 더 많은 최적화 기법을 적용하여 시스템의 성능을 극대화합니다.
2. 모니터링 및 관리: 시스템의 상태를 모니터링하고, 필요한 경우 관리를 위한 기능을 추가합니다.

 

Step 1: 성능 향상

더 많은 최적화 기법을 적용하여 시스템의 성능을 극대화합니다. 예를 들어, 효율적인 메모리 사용과 적절한 스레드 관리 기법을 적용합니다.

 

DataCollector 클래스 개선

DataCollector.h

#ifndef DATACOLLECTOR_H
#define DATACOLLECTOR_H

#include <string>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <atomic>
#include <vector>

class DataCollector {
private:
    std::queue<std::string> dataQueue;
    std::mutex mtx;
    std::condition_variable cv;
    std::atomic<bool> stopFlag;
    std::thread collectorThread;

    void collectDataFromFile(const std::string& fileName);

public:
    DataCollector();
    ~DataCollector();
    void startCollecting(const std::string& fileName);
    void stopCollecting();
    std::string getNextData();
    size_t queueSize() const;
};

#endif // DATACOLLECTOR_H

 

DataCollector.cpp

#include "DataCollector.h"
#include <fstream>
#include <iostream>

DataCollector::DataCollector() : stopFlag(false) {}

DataCollector::~DataCollector() {
    stopCollecting();
}

void DataCollector::startCollecting(const std::string& fileName) {
    collectorThread = std::thread(&DataCollector::collectDataFromFile, this, fileName);
}

void DataCollector::stopCollecting() {
    stopFlag = true;
    cv.notify_all();
    if (collectorThread.joinable()) {
        collectorThread.join();
    }
}

void DataCollector::collectDataFromFile(const std::string& fileName) {
    std::ifstream file(fileName);
    if (!file) {
        std::cerr << "Failed to open file: " << fileName << std::endl;
        return;
    }

    std::string line;
    while (std::getline(file, line) && !stopFlag) {
        {
            std::unique_lock<std::mutex> lock(mtx);
            dataQueue.push(line);
        }
        cv.notify_one();
    }
}

std::string DataCollector::getNextData() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [this] { return !dataQueue.empty() || stopFlag; });
    if (dataQueue.empty()) {
        return "";
    }
    std::string data = dataQueue.front();
    dataQueue.pop();
    return data;
}

size_t DataCollector::queueSize() const {
    std::lock_guard<std::mutex> lock(mtx);
    return dataQueue.size();
}

 

Step 2: 모니터링 및 관리

시스템의 상태를 모니터링하고, 필요한 경우 관리를 위한 기능을 추가합니다. 예를 들어, 현재 큐의 크기와 처리된 데이터 수를 모니터링합니다.

 

SystemMonitor 클래스 설계

SystemMonitor.h

#ifndef SYSTEMMONITOR_H
#define SYSTEMMONITOR_H

#include "DataCollector.h"
#include "Logger.h"
#include <atomic>
#include <thread>
#include <chrono>

class SystemMonitor {
private:
    DataCollector& collector;
    Logger& logger;
    std::atomic<bool> stopFlag;
    std::thread monitorThread;

    void monitor();

public:
    SystemMonitor(DataCollector& collector, Logger& logger);
    ~SystemMonitor();
    void startMonitoring();
    void stopMonitoring();
};

#endif // SYSTEMMONITOR_H

 

SystemMonitor.cpp

#include "SystemMonitor.h"

SystemMonitor::SystemMonitor(DataCollector& collector, Logger& logger)
    : collector(collector), logger(logger), stopFlag(false) {}

SystemMonitor::~SystemMonitor() {
    stopMonitoring();
}

void SystemMonitor::startMonitoring() {
    monitorThread = std::thread(&SystemMonitor::monitor, this);
}

void SystemMonitor::stopMonitoring() {
    stopFlag = true;
    if (monitorThread.joinable()) {
        monitorThread.join();
    }
}

void SystemMonitor::monitor() {
    while (!stopFlag) {
        size_t queueSize = collector.queueSize();
        logger.log("Current queue size: " + std::to_string(queueSize));
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

 

Step 3: 통합 테스트

모든 기능을 통합하여 테스트합니다.

 

main.cpp

#include "DataCollector.h"
#include "DataProcessor.h"
#include "DataStorage.h"
#include "Logger.h"
#include "SystemMonitor.h"
#include <thread>
#include <vector>

int main() {
    DataCollector collector;
    DataProcessor processor;
    DataStorage storage;
    Logger logger("system.log");
    SystemMonitor monitor(collector, logger);

    // 데이터 수집 시작
    collector.startCollecting("data.txt");

    // 시스템 모니터링 시작
    monitor.startMonitoring();

    // 데이터 처리 및 저장 시작
    processor.startProcessing(4, [&collector]() {
        std::string data = collector.getNextData();
        return data;
    }, [&storage, &logger](const std::string& data) {
        // 데이터 처리 예제
        logger.log("Processing data: " + data);
        storage.storeData(data, "processed_data.txt");
    });

    std::this_thread::sleep_for(std::chrono::seconds(5));

    // 시스템 종료
    collector.stopCollecting();
    processor.stopProcessing();
    monitor.stopMonitoring();

    return 0;
}

 

데이터 파일 준비

데이터 수집을 테스트하기 위해 data.txt 파일을 준비합니다. 이 파일에는 테스트할 데이터가 포함되어야 합니다.

data.txt

Sample data line 1
Sample data line 2
Sample data line 3
...

 

이제 스물아홉 번째 날의 학습을 마쳤습니다. 실시간 데이터 처리 시스템 개발 프로젝트의 세 번째 단계를 통해 성능을 더욱 향상시키고, 시스템의 모니터링 및 관리 기능을 추가했습니다.

질문이나 피드백이 있으면 언제든지 댓글로 남겨 주세요. 내일은 "최적화 및 고급 테크닉 요약 및 결론"에 대해 학습하겠습니다.