C++ में कार्य शेड्यूलर: कार्यों का निर्माण और प्रबंधन

C++ में कार्य शेड्यूलर: पूर्ण गाइड

कार्य शेड्यूलर (Task Scheduler) एक शक्तिशाली उपकरण है, जो निर्धारित समय पर या निश्चित अंतराल पर कोड के निष्पादन को स्वचालित करने की अनुमति देता है। C++ में ऐसे शेड्यूलर को लागू करने के लिए मल्टीथ्रेडिंग, सिंक्रोनाइज़ेशन और समय अंतराल के साथ काम करने की समझ आवश्यक है। इस लेख में, हम मानक C++ लाइब्रेरी (C++11 और नए) का उपयोग करके शुरुआत से अपना स्वयं का कार्य शेड्यूलर बनाने का तरीका समझेंगे।

शेड्यूलर के मुख्य घटक

किसी भी कार्य शेड्यूलर में कई प्रमुख तत्व होते हैं:

• कार्य भंडार — शेड्यूल किए गए कार्यों को संग्रहीत करने के लिए कतार या कंटेनर।
• टाइमर — एक तंत्र जो यह निर्धारित करता है कि कार्य कब निष्पादित किया जाना चाहिए।
• थ्रेड पूल — मुख्य थ्रेड को ब्लॉक किए बिना समानांतर निष्पादन के लिए।
• रद्दीकरण तंत्र — कार्य के निष्पादन से पहले उसे रद्द करने की क्षमता।

एकल थ्रेड के साथ सरल शेड्यूलर कार्यान्वयन

आइए एक बुनियादी उदाहरण से शुरू करें, जहाँ कार्य पृष्ठभूमि थ्रेड में क्रमिक रूप से निष्पादित होते हैं:

#include <iostream>#include <thread>#include <chrono>#include <functional>#include <queue>#include <mutex>#include <condition_variable>

class TaskScheduler {public:    // विलंब के साथ कार्य शेड्यूल करता है    void schedule(std::function<void()> task, int delay_ms) {        std::lock_guard<std::mutex> lock(mutex_);        tasks_.push({std::chrono::steady_clock::now() +                      std::chrono::milliseconds(delay_ms), task});        cv_.notify_one();    }

    // शेड्यूलर को एक अलग थ्रेड में शुरू करता है    void start() {        worker_ = std::thread([this]() {            while (!stop_) {                std::unique_lock<std::mutex> lock(mutex_);                if (tasks_.empty()) {                    cv_.wait(lock, [this]() {                         return !tasks_.empty() || stop_;                     });                }                if (stop_) break;

                auto now = std::chrono::steady_clock::now();                auto& top = tasks_.top();                if (top.time <= now) {                    auto task = top.task;                    tasks_.pop();                    lock.unlock();                    task(); // कार्य निष्पादित करें                } else {                    cv_.wait_until(lock, top.time);                }            }        });    }

    void stop() {        stop_ = true;        cv_.notify_all();        if (worker_.joinable()) worker_.join();    }

private:    struct Task {        std::chrono::steady_clock::time_point time;        std::function<void()> task;        bool operator>(const Task& other) const {            return time > other.time;        }    };

    std::priority_queue<Task, std::vector<Task>, std::greater<Task>> tasks_;    std::mutex mutex_;    std::condition_variable cv_;    std::thread worker_;    bool stop_ = false;};

int main() {    TaskScheduler scheduler;    scheduler.start();

    scheduler.schedule([]() {        std::cout << "कार्य 1 2 सेकंड के बाद निष्पादित हुआ";    }, 2000);

    scheduler.schedule([]() {        std::cout << "कार्य 2 1 सेकंड के बाद निष्पादित हुआ";    }, 1000);

    std::this_thread::sleep_for(std::chrono::seconds(3));    scheduler.stop();    return 0;}

समानांतर निष्पादन के लिए थ्रेड पूल के साथ शेड्यूलर

अधिक जटिल परिदृश्यों के लिए, जहाँ कार्य लंबे समय तक चल सकते हैं, थ्रेड पूल का उपयोग करना बेहतर है। यहाँ न्यूनतम पूल के साथ एक उदाहरण है:

#include <vector>#include <queue>#include <thread>#include <mutex>#include <condition_variable>#include <f