C++17 ਤੋਂ std::shared_mutex ਨੂੰ ਸਮਝਣਾ

std::shared_mutex, C++17 ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ, ਇੱਕ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਪ੍ਰਾਈਮਿਟਿਵ ਹੈ ਜੋ ਇੱਕ ਤੋਂ ਵੱਧ ਥ੍ਰੈਡਾਂ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਸ਼ੇਅਰਡ (ਪੜ੍ਹਨ) ਲਾਕ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਲਿਖਣ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ ਪਹੁੰਚ ਨੂੰ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਾਂ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ APIs ਤੱਕ ਪਹੁੰਚ ਕੀਤੇ ਬਿਨਾਂ ਰੀਡਰ-ਰਾਈਟਰ ਲੌਕਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਇੱਕ ਸਾਫ਼, ਮਿਆਰੀ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਕੇ ਆਧੁਨਿਕ C++ ਵਿੱਚ ਸਭ ਤੋਂ ਆਮ ਸਮਕਾਲੀ ਚੁਣੌਤੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।

ਅਸਲ ਵਿੱਚ std::shared_mutex ਕੀ ਹੈ ਅਤੇ ਇਸਨੂੰ C++17 ਵਿੱਚ ਕਿਉਂ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ?

C++17 ਤੋਂ ਪਹਿਲਾਂ, ਡਿਵੈਲਪਰ ਜਿਨ੍ਹਾਂ ਨੂੰ ਪਾਠਕ-ਲੇਖਕ ਅਰਥ ਵਿਗਿਆਨ ਦੀ ਲੋੜ ਸੀ, ਉਹਨਾਂ ਨੂੰ ਪਲੇਟਫਾਰਮ-ਵਿਸ਼ੇਸ਼ ਹੱਲ ਜਿਵੇਂ ਕਿ POSIX ਸਿਸਟਮਾਂ 'ਤੇ pthread_rwlock_t ਜਾਂ Windows 'ਤੇ SRWLOCK 'ਤੇ ਨਿਰਭਰ ਕਰਨਾ ਪੈਂਦਾ ਸੀ, ਜਾਂ ਉਹ ਤੀਜੀ-ਧਿਰ ਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਿਵੇਂ ਕਿ ਬੂਸਟ ਦੀ ਵਰਤੋਂ ਕਰਨਗੇ। C++17 ਸਟੈਂਡਰਡ ਕਮੇਟੀ ਨੇ ਇਸ ਅੰਤਰ ਨੂੰ ਮਾਨਤਾ ਦਿੱਤੀ ਅਤੇ ਇਸਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਹੱਲ ਕਰਨ ਲਈ ਸਿਰਲੇਖ ਵਿੱਚ std::shared_mutex ਪੇਸ਼ ਕੀਤਾ।

ਮੁੱਖ ਵਿਚਾਰ ਸਿੱਧਾ ਹੈ: ਬਹੁਤ ਸਾਰੇ ਅਸਲ-ਸੰਸਾਰ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ, ਡੇਟਾ ਨੂੰ ਲਿਖਿਆ ਗਿਆ ਹੈ ਨਾਲੋਂ ਕਿਤੇ ਵੱਧ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਮਿਆਰੀ std::mutex ਸਾਰੀ ਪਹੁੰਚ ਨੂੰ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ — ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ — ਜੋ ਬੇਲੋੜੀਆਂ ਰੁਕਾਵਟਾਂ ਪੈਦਾ ਕਰਦਾ ਹੈ। std::shared_mutex ਦੋ ਲਾਕਿੰਗ ਮੋਡਾਂ ਵਿੱਚ ਫਰਕ ਕਰਕੇ ਪਾਬੰਦੀ ਹਟਾ ਦਿੰਦਾ ਹੈ:

• ਸਾਂਝਾ (ਪੜ੍ਹਿਆ) ਲਾਕ — lock_shared() ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ; ਮਲਟੀਪਲ ਥ੍ਰੈੱਡ ਇਸ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਰੱਖ ਸਕਦੇ ਹਨ, ਇਸ ਨੂੰ ਸਮਕਾਲੀ ਪੜ੍ਹਨ ਲਈ ਆਦਰਸ਼ ਬਣਾਉਂਦੇ ਹਨ।
• ਨਿਵੇਕਲਾ (ਲਿਖਣ) ਲਾਕ — lock() ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ; ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਥ੍ਰੈੱਡ ਇਸ ਨੂੰ ਰੱਖ ਸਕਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਹੋਲਡ ਕਰਨ ਵੇਲੇ ਕਿਸੇ ਵੀ ਸਾਂਝੇ ਤਾਲੇ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ।
• std::shared_lock — ਇੱਕ RAII ਰੈਪਰ ਜੋ ਕਿ ਨਿਰਮਾਣ 'ਤੇ lock_shared() ਅਤੇ ਤਬਾਹੀ 'ਤੇ unlock_shared(), ਸਰੋਤ ਲੀਕ ਨੂੰ ਰੋਕਦਾ ਹੈ।
• std::unique_lock / std::lock_guard — ਨਿਵੇਕਲੇ ਮੋਡ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਲਿਖਣ ਦੇ ਕੰਮ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੁਰੱਖਿਅਤ ਹਨ ਅਤੇ ਅਪਵਾਦ-ਸੁਰੱਖਿਅਤ ਹਨ।

ਇਹ ਦੋਹਰਾ-ਮੋਡ ਡਿਜ਼ਾਈਨ std::shared_mutex ਨੂੰ ਕੈਚ, ਕੌਂਫਿਗਰੇਸ਼ਨ ਰਜਿਸਟਰੀਆਂ, ਅਤੇ ਕਿਸੇ ਵੀ ਡੇਟਾ ਢਾਂਚੇ ਲਈ ਇੱਕ ਕੁਦਰਤੀ ਫਿੱਟ ਬਣਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਰੀਡ ਵਰਕਲੋਡ ਉੱਤੇ ਹਾਵੀ ਹੁੰਦੀ ਹੈ।

ਤੁਸੀਂ ਟਿੱਪਣੀਆਂ ਦੇ ਨਾਲ ਅਸਲ ਕੋਡ ਵਿੱਚ std::shared_mutex ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦੇ ਹੋ?

ਕੋਡ ਵਿੱਚ ਟਿੱਪਣੀਆਂ ਜੋ std::shared_mutex ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ ਖਾਸ ਤੌਰ 'ਤੇ ਕੀਮਤੀ ਹਨ ਕਿਉਂਕਿ ਸਮਕਾਲੀ ਤਰਕ ਬਾਰੇ ਤਰਕ ਕਰਨਾ ਬਹੁਤ ਔਖਾ ਹੈ। ਚੰਗੀ ਤਰ੍ਹਾਂ ਰੱਖੀਆਂ ਗਈਆਂ ਟਿੱਪਣੀਆਂ ਸਪੱਸ਼ਟ ਕਰਦੀਆਂ ਹਨ ਕਿ ਕਿਉਂ ਇੱਕ ਖਾਸ ਲਾਕ ਕਿਸਮ ਦੀ ਚੋਣ ਕੀਤੀ ਗਈ ਸੀ, ਜੋ ਕਿ ਭਵਿੱਖ ਦੇ ਰੱਖਿਅਕਾਂ ਦੁਆਰਾ ਅਚਾਨਕ ਡਾਟਾ ਰੇਸ ਸ਼ੁਰੂ ਕਰਨ ਦੇ ਜੋਖਮ ਨੂੰ ਨਾਟਕੀ ਢੰਗ ਨਾਲ ਘਟਾਉਂਦੀ ਹੈ। ਇੱਥੇ ਇੱਕ ਆਮ ਪੈਟਰਨ ਹੈ:

#include 
# includ 
# ਸ਼ਾਮਲ ਕਰੋ 

ਕਲਾਸ ConfigRegistry {
    mutable std::shared_mutex mtx_; // ਹੇਠਾਂ ਦਿੱਤੇ ਨਕਸ਼ੇ ਦੀ ਰੱਖਿਆ ਕਰਦਾ ਹੈ
    std::unordered_map data_;

ਜਨਤਕ:
    // ਰੀਡ ਪਾਥ: ਮਲਟੀਪਲ ਥ੍ਰੈਡਸ ਇਸ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਾਲ ਕਰ ਸਕਦੇ ਹਨ
    std::string get(const std::string& key) const {
        std::shared_lock lock(mtx_); // ਸਾਂਝਾ ਲਾਕ — ਸਮਕਾਲੀ ਰੀਡਿੰਗ ਲਈ ਸੁਰੱਖਿਅਤ
        auto it = data_.find(key);
        ਇਸ ਨੂੰ ਵਾਪਸ ਕਰੋ!= data_.end()? it->ਦੂਜਾ : "";
    }

    // ਲਿਖੋ ਮਾਰਗ: ਵਿਸ਼ੇਸ਼ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੈ
    void ਸੈੱਟ(const std::string& key, const std::string&val) {
        std::unique_lock lock(mtx_); // ਵਿਸ਼ੇਸ਼ ਲਾਕ — ਸਾਰੇ ਪਾਠਕਾਂ ਨੂੰ ਬਲੌਕ ਕਰਦਾ ਹੈ
        data__[key] = val;
    }
};

ਨੋਟ ਕਰੋ ਕਿ ਟਿੱਪਣੀਆਂ ਹਰ ਇੱਕ ਲਾਕ ਵਿਕਲਪ ਦੇ ਪਿੱਛੇ ਇਰਾਦੇ ਦੀ ਵਿਆਖਿਆ ਕਿਵੇਂ ਕਰਦੀਆਂ ਹਨ ਨਾ ਕਿ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ। ਇਹ ਸੋਨੇ ਦਾ ਮਿਆਰ ਹੈ: ਟਿੱਪਣੀਆਂ ਨੂੰ ਕਿਉਂ ਦਾ ਜਵਾਬ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕਿ ਕੀ। mutex 'ਤੇ mutable ਕੀਵਰਡ get() ਨੂੰ const ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਅਜੇ ਵੀ ਲਾਕ ਕਰਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ, ਇੱਕ ਆਮ ਅਤੇ ਮੁਹਾਵਰੇ ਵਾਲਾ ਪੈਟਰਨ।

ਕੁੰਜੀ ਸਮਝ: ਹਮੇਸ਼ਾ std::shared_mutex ਨਾਲ RAII ਲਾਕ ਰੈਪਰ (std::shared_lock, std::unique_lock) ਦੀ ਵਰਤੋਂ ਕਰੋ — lock() ਅਤੇ manual() ਨੂੰ ਕਦੇ ਵੀ ਕਾਲ ਨਾ ਕਰੋ। ਅਪਵਾਦਾਂ ਦੀ ਮੌਜੂਦਗੀ ਵਿੱਚ ਮੈਨੂਅਲ ਲਾਕਿੰਗ ਡੈੱਡਲਾਕ ਅਤੇ ਅਣ-ਪ੍ਰਭਾਸ਼ਿਤ ਵਿਵਹਾਰ ਲਈ ਇੱਕ ਗਾਰੰਟੀਸ਼ੁਦਾ ਮਾਰਗ ਹੈ।

std::shared_mutex ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਆਮ ਸਮੱਸਿਆਵਾਂ ਕੀ ਹਨ?

ਸਪੱਸ਼ਟ ਟਿੱਪਣੀਆਂ ਅਤੇ ਚੰਗੇ ਇਰਾਦਿਆਂ ਦੇ ਨਾਲ ਵੀ, std::shared_mutex ਵਿੱਚ ਸੂਖਮ ਜਾਲ ਹਨ ਜੋ ਤਜਰਬੇਕਾਰ ਡਿਵੈਲਪਰਾਂ ਦੀ ਯਾਤਰਾ ਕਰਦੇ ਹਨ। ਸਭ ਤੋਂ ਖ਼ਤਰਨਾਕ ਲਾਕ ਅੱਪਗ੍ਰੇਡ ਹੈ: ਸਾਂਝੇ ਲਾਕ ਨੂੰ ਪਹਿਲਾਂ ਜਾਰੀ ਕੀਤੇ ਬਿਨਾਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਲਾਕ ਵਿੱਚ ਅੱਪਗ੍ਰੇਡ ਕਰਨ ਦਾ ਕੋਈ ਬਿਲਟ-ਇਨ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਜਾਰੀ ਕੀਤੇ ਬਿਨਾਂ ਅਜਿਹਾ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਨਾਲ ਇੱਕ ਤਤਕਾਲ ਡੈੱਡਲਾਕ ਪੈਦਾ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਥ੍ਰੈੱਡ ਵਿੱਚ ਇੱਕ ਸਾਂਝਾ ਲਾਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਕਿ ਨਿਵੇਕਲੇ ਲੌਕ ਦੀ ਉਡੀਕ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸਨੂੰ ਕਦੇ ਵੀ ਉਦੋਂ ਤੱਕ ਮਨਜ਼ੂਰੀ ਨਹੀਂ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਜਦੋਂ ਤੱਕ ਕੋਈ ਸਾਂਝਾ ਲਾਕ ਮੌਜੂਦ ਹੈ — ਜਿਸ ਵਿੱਚ ਇਹ ਹੋਲਡ ਕੀਤਾ ਹੋਇਆ ਹੈ।

ਇੱਕ ਹੋਰ ਆਮ ਗਲਤੀ ਗਲਤ ਗ੍ਰੈਨਿਊਲਿਟੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਹੈ। ਡਿਵੈਲਪਰ ਕਦੇ-ਕਦਾਈਂ ਪਾਠਕ-ਲੇਖਕ ਪੈਟਰਨ ਦੇ ਉਦੇਸ਼ ਨੂੰ ਹਰਾ ਕੇ, ਜਾਂ ਬਹੁਤ ਤੰਗ ਢੰਗ ਨਾਲ, ਵਿੰਡੋਜ਼ ਨੂੰ ਛੱਡ ਕੇ, ਜਿੱਥੇ ਦੋ ਵੱਖ-ਵੱਖ ਲਾਕ ਐਕਵਾਇਰਮੈਂਟਾਂ ਦੇ ਵਿਚਕਾਰ ਇਨਵੈਰੀਐਂਟਸ ਦੀ ਉਲੰਘਣਾ ਹੁੰਦੀ ਹੈ, ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲਾਕ ਕਰ ਦਿੰਦੇ ਹਨ। ਟਿੱਪਣੀਆਂ ਜੋ ਅਨਵੇਰੀਏਂਟ ਸੁਰੱਖਿਅਤ ਹੋਣ ਦਾ ਵਰਣਨ ਕਰਦੀਆਂ ਹਨ, ਨਾ ਕਿ ਸਿਰਫ਼ ਵੇਰੀਏਬਲ ਨੂੰ ਲਾਕ ਕੀਤੇ ਜਾਣ ਦੀ ਬਜਾਏ, ਟੀਮਾਂ ਨੂੰ ਕੋਡ ਸਮੀਖਿਆ ਦੌਰਾਨ ਸਹੀ ਹੋਣ ਬਾਰੇ ਤਰਕ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਪ੍ਰਦਰਸ਼ਨ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਵੀ ਕਰ ਸਕਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਲੇਖਕਾਂ ਦੇ ਨਾਲ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਵਾਦਿਤ ਸਿਸਟਮਾਂ 'ਤੇ, ਵਾਧੂ ਬੁੱਕਕੀਪਿੰਗ ਓਵਰਹੈੱਡ ਦੇ ਕਾਰਨ, std::shared_mutex ਅਸਲ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ std::mutex ਨਾਲੋਂ ਵੀ ਮਾੜਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਮੰਨਣ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਪਾਠਕ-ਲੇਖਕ ਨੂੰ ਲਾਕ ਕਰਨਾ ਇੱਕ ਸ਼ੁੱਧ ਜਿੱਤ ਹੈ।

std::shared_mutex ਦੀ ਤੁਲਨਾ std::mutex ਅਤੇ ਹੋਰ ਵਿਕਲਪਾਂ ਨਾਲ ਕਿਵੇਂ ਹੁੰਦੀ ਹੈ?

std::mutex ਝਗੜਾ ਘੱਟ ਹੋਣ 'ਤੇ ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੌਖਾ, ਤੇਜ਼ ਹੈ, ਅਤੇ ਜਦੋਂ ਪੜ੍ਹਨਾ ਅਤੇ ਲਿਖਣਾ ਲਗਭਗ ਬਰਾਬਰ ਬਾਰੰਬਾਰਤਾ 'ਤੇ ਹੁੰਦਾ ਹੈ ਤਾਂ ਉਚਿਤ ਹੈ। std::shared_mutex ਉਦੋਂ ਚਮਕਦਾ ਹੈ ਜਦੋਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਲਿਖਣ ਦੀ ਗਿਣਤੀ ਕਾਫ਼ੀ ਵੱਧ ਜਾਂਦੀ ਹੈ — ਇੱਕ 10:1 ਜਾਂ ਇਸ ਤੋਂ ਵੱਧ ਅਨੁਪਾਤ ਸਵਿੱਚ 'ਤੇ ਵਿਚਾਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅੰਗੂਠੇ ਦਾ ਇੱਕ ਉਚਿਤ ਨਿਯਮ ਹੈ।

C++14 ਨੇ std::shared_timed_mutex ਨੂੰ ਪੇਸ਼ ਕੀਤਾ, ਜੋ ਸਮਾਂਬੱਧ ਕੋਸ਼ਿਸ਼ਾਂ ਲਈ try_lock_shared_for() ਅਤੇ try_lock_shared_until() ਜੋੜਦਾ ਹੈ। C++17 ਦਾ std::shared_mutex ਲੀਨਰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਮਾਂਬੱਧ ਰੂਪਾਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਸਾਂਝੇ ਮਾਰਗ 'ਤੇ ਸਮਾਂਬੱਧ ਲਾਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ std::shared_timed_mutex ਉਪਲਬਧ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਦੋਵੇਂ ਕਿਸਮਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਿਆਰੀ ਹਨ।

ਲਾਕ-ਮੁਕਤ ਵਿਕਲਪਾਂ ਲਈ, std::atomic ਸਾਵਧਾਨੀਪੂਰਵਕ ਮੈਮੋਰੀ ਆਰਡਰਿੰਗ ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ ਕਈ ਵਾਰ ਸਧਾਰਨ ਫਲੈਗ ਜਾਂ ਕਾਊਂਟਰਾਂ ਲਈ ਇੱਕ ਮਿਊਟੇਕਸ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਦਲ ਸਕਦਾ ਹੈ, ਪਰ ਗੁੰਝਲਦਾਰ ਡਾਟਾ ਢਾਂਚੇ ਲਈ, std::shared_mutex ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਸਾਂਭਣਯੋਗ ਹੱਲ ਹੈ।

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

ਕੀ std::shared_mutex ਭੁੱਖਮਰੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦਾ ਹੈ?

ਹਾਂ, ਇਹ ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਨਵੇਂ ਸ਼ੇਅਰ-ਲਾਕ ਹੋਲਡਰ ਲਗਾਤਾਰ ਆਉਂਦੇ ਰਹਿੰਦੇ ਹਨ, ਤਾਂ ਇੱਕ ਨਿਵੇਕਲਾ-ਲਾਕ ਬੇਨਤੀਕਰਤਾ ਅਣਮਿੱਥੇ ਸਮੇਂ ਲਈ ਉਡੀਕ ਕਰ ਸਕਦਾ ਹੈ — ਇੱਕ ਕਲਾਸਿਕ ਲੇਖਕ ਭੁੱਖਮਰੀ ਸਮੱਸਿਆ। C++ ਸਟੈਂਡਰਡ ਕਿਸੇ ਖਾਸ ਨਿਰਪੱਖਤਾ ਨੀਤੀ ਨੂੰ ਲਾਜ਼ਮੀ ਨਹੀਂ ਕਰਦਾ, ਇਸਲਈ ਵਿਵਹਾਰ ਲਾਗੂ ਕਰਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਅਭਿਆਸ ਵਿੱਚ, ਜ਼ਿਆਦਾਤਰ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਲਾਗੂਕਰਨ ਬਕਾਇਆ ਵਿਸ਼ੇਸ਼ ਲਾਕ ਨੂੰ ਇੱਕ ਵਾਰ ਕਤਾਰ ਵਿੱਚ ਲਗਾਉਣ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ, ਪਰ ਤੁਹਾਨੂੰ ਆਪਣੇ ਖਾਸ ਟੂਲਚੇਨ ਅਤੇ ਪਲੇਟਫਾਰਮ ਲਈ ਇਸਦੀ ਪੁਸ਼ਟੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜੇਕਰ ਉਤਪਾਦਨ ਵਿੱਚ ਭੁੱਖਮਰੀ ਇੱਕ ਚਿੰਤਾ ਹੈ।

ਕੀ std::shared_mutex std::condition_variable ਨਾਲ ਵਰਤਣ ਲਈ ਸੁਰੱਖਿਅਤ ਹੈ?

std::condition_variable ਨੂੰ ਇੱਕ std::unique_lock ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇਸਲਈ ਇਹ std::shared_mutex ਨਾਲ ਸਿੱਧਾ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਸ਼ੇਅਰਡ ਮਿਊਟੈਕਸ ਨੂੰ ਰੱਖਣ ਦੌਰਾਨ ਕਿਸੇ ਸ਼ਰਤ 'ਤੇ ਇੰਤਜ਼ਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ std::condition_variable_any ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਕਿਸੇ ਵੀ BasicLockable ਕਿਸਮ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ std::shared_mutex ਨੂੰ std::shared_lock ਨਾਲ ਜੋੜਿਆ ਗਿਆ ਹੈ।

ਕੀ ਹਰ ਵਾਰ ਜਦੋਂ ਮੈਂ std::shared_mutex ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ ਤਾਂ ਕੀ ਮੈਨੂੰ ਟਿੱਪਣੀਆਂ ਸ਼ਾਮਲ ਕਰਨੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ?

ਘੱਟੋ-ਘੱਟ, ਇਹ ਵਰਣਨ ਕਰਨ ਲਈ ਮਿਊਟੈਕਸ ਦੀ ਘੋਸ਼ਣਾ 'ਤੇ ਟਿੱਪਣੀ ਕਰੋ ਕਿ ਇਹ ਕਿਹੜੇ ਡੇਟਾ ਦੀ ਰੱਖਿਆ ਕਰਦਾ ਹੈ ਅਤੇ ਇਨਵੇਰੀਐਂਟ ਇਸ ਨੂੰ ਕਾਇਮ ਰੱਖਦਾ ਹੈ। ਹਰੇਕ ਲਾਕ ਸਾਈਟ 'ਤੇ, ਇੱਕ ਸੰਖੇਪ ਟਿੱਪਣੀ ਇਹ ਦੱਸਦੀ ਹੈ ਕਿ ਸਾਂਝੀ ਬਨਾਮ ਨਿਵੇਕਲੀ ਪਹੁੰਚ ਕਿਉਂ ਚੁਣੀ ਗਈ ਸੀ, ਕੋਡ ਸਮੀਖਿਅਕਾਂ ਅਤੇ ਭਵਿੱਖ ਦੇ ਰੱਖ-ਰਖਾਅ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਮੁੱਲ ਜੋੜਦੀ ਹੈ। ਕਨਕਰੰਸੀ ਬੱਗ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨ ਅਤੇ ਠੀਕ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਔਖੇ ਹਨ, ਇਸਲਈ ਸਪਸ਼ਟ, ਸਟੀਕ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਈ ਗੁਣਾ ਵੱਧ ਲਾਭਅੰਸ਼ ਦਾ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ।

ਜਟਿਲ ਪ੍ਰਣਾਲੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ — ਭਾਵੇਂ ਸਮਕਾਲੀ C++ ਕੋਡ ਹੋਵੇ ਜਾਂ ਇੱਕ ਪੂਰਾ ਵਪਾਰਕ ਸੰਚਾਲਨ — ਸਹੀ ਸਾਧਨਾਂ ਅਤੇ ਸਪਸ਼ਟ ਢਾਂਚੇ ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ। Mewayz 138,000 ਤੋਂ ਵੱਧ ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਭਰੋਸੇਯੋਗ 207-ਮੌਡਿਊਲ ਕਾਰੋਬਾਰੀ OS ਹੈ, ਜੋ ਕਿ ਮਾਰਕੀਟਿੰਗ, CRM, ਈ-ਕਾਮਰਸ, ਵਿਸ਼ਲੇਸ਼ਣ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਲਈ ਇੱਕੋ ਹੀ ਸਪੱਸ਼ਟਤਾ ਲਿਆਉਣ ਲਈ, ਸਾਰੇ ਇੱਕ ਪਲੇਟਫਾਰਮ ਵਿੱਚ ਸਿਰਫ $19 ਪ੍ਰਤੀ ਮਹੀਨਾ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਦਰਜਨਾਂ ਡਿਸਕਨੈਕਟ ਕੀਤੇ ਟੂਲਾਂ ਨੂੰ ਜੁਗਲ ਕਰਨਾ ਬੰਦ ਕਰੋ ਅਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਈਨ ਕੀਤੇ ਸੌਫਟਵੇਅਰ ਦੀ ਸ਼ੁੱਧਤਾ ਨਾਲ ਆਪਣੇ ਕਾਰੋਬਾਰ ਨੂੰ ਚਲਾਉਣਾ ਸ਼ੁਰੂ ਕਰੋ। ਅੱਜ ਹੀ app.mewayz.com 'ਤੇ Mewayz ਅਜ਼ਮਾਓ ਅਤੇ ਦੇਖੋ ਕਿ ਕਿਵੇਂ ਇੱਕ ਯੂਨੀਫਾਈਡ ਸਿਸਟਮ ਤੁਹਾਡੀ ਟੀਮ ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲਦਾ ਹੈ।