C++
सिकंदरा

परिचय

सेमाफोर सी ++ 11

#include <mutex>
#include <condition_variable>
        
class Semaphore {
public:
    Semaphore (int count_ = 0)
    : count(count_) 
    {
    }
    
    inline void notify( int tid ) {
        std::unique_lock<std::mutex> lock(mtx);
        count++;
        cout << "thread " << tid <<  " notify" << endl;
        //notify the waiting thread
        cv.notify_one();
    }
    inline void wait( int tid ) {
        std::unique_lock<std::mutex> lock(mtx);
        while(count == 0) {
            cout << "thread " << tid << " wait" << endl;
            //wait on the mutex until notify is called
            cv.wait(lock);
            cout << "thread " << tid << " run" << endl;
        }
        count--;
    }
private:
    std::mutex mtx;
    std::condition_variable cv;
    int count;
};

कार्रवाई में सेमाफोर वर्ग

निम्न फ़ंक्शन चार थ्रेड्स जोड़ता है। तीन धागे सेमाफोर के लिए प्रतिस्पर्धा करते हैं, जो एक की गिनती के लिए सेट है। एक धीमी थ्रेड notify_one() कॉल notify_one() , जिससे किसी एक प्रतीक्षा सूत्र को आगे बढ़ने की अनुमति मिलती है।

इसका परिणाम यह होता है कि s1 तुरंत घूमना शुरू कर देता है, जिससे सेमाफोर की उपयोग count नीचे बनी रहती है। अन्य सूत्र सूचना चर पर बदले में प्रतीक्षा करते हैं जब तक कि सूचना () को नहीं कहा जाता है।

int main()
{
    Semaphore sem(1);
    
    thread s1([&]() {
        while(true) {
            this_thread::sleep_for(std::chrono::seconds(5));
            sem.wait( 1 );
        }           
    });
    thread s2([&]() {
        while(true){
            sem.wait( 2 );
        }
    });
    thread s3([&]() {
        while(true) {
            this_thread::sleep_for(std::chrono::milliseconds(600));
            sem.wait( 3 );
        }
    });
    thread s4([&]() {
        while(true) {
            this_thread::sleep_for(std::chrono::seconds(5));
            sem.notify( 4 );
        }
    });
    
    
    s1.join();
    s2.join();
    s3.join();
    s4.join();

    ...
    }