std :: unique_lock <std :: mutex> veya std :: lock_guard <std :: mutex>?

İki kullanım durumum var.

A. İki iş parçacığı tarafından bir kuyruğa erişimi eşitlemek istiyorum.

B. İki kuyruğun erişimini bir kuyruğa eşitlemek ve bir koşul değişkeni kullanmak istiyorum, çünkü iş parçacıklarından biri diğer iş parçacığı tarafından kuyruğa kaydedilecek içerikte bekler.

AI kullanımı örneği için kod örneğine bakın std::lock_guard<>. Kullanım senaryosu BI için kod örneğine bakınız std::unique_lock<>.

İkisi arasındaki fark nedir ve hangi kullanım durumunda hangisini kullanmalıyım?

Aradaki fark, kilitleyip kilidini açabilmenizdir std::unique_lock. std::lock_guardinşaatta sadece bir kez kilitlenir ve yıkım sırasında kilidi açılır.

Bu nedenle, kullanım durumu B std::unique_lockiçin koşul değişkeni için kesinlikle bir a ihtiyacınız vardır . A durumunda, korumayı yeniden kilitlemeniz gerekip gerekmediğine bağlıdır.

std::unique_lockörneğin, muteksi hemen kilitlemeden, ancak RAII sargısını oluşturmak için inşa edilmesine izin veren başka özelliklere de sahiptir ( buraya bakın ).

std::lock_guardayrıca uygun bir RAII sarmalayıcı sağlar, ancak birden fazla muteksi güvenli bir şekilde kilitleyemez. Sınırlı bir kapsam için bir sargıya ihtiyacınız olduğunda kullanılabilir, örneğin: bir üye işlevi:

class MyClass{
    std::mutex my_mutex;
    void member_foo() {
        std::lock_guard<mutex_type> lock(this->my_mutex);            
        /*
         block of code which needs mutual exclusion (e.g. open the same 
         file in multiple threads).
        */

        //mutex is automatically released when lock goes out of scope           
};

Bir soruyu chmike ile açıklığa kavuşturmak için, varsayılan olarak std::lock_guardve std::unique_lockaynıdır. Yani yukarıdaki durumda, std::lock_guardile değiştirebilirsiniz std::unique_lock. Ancak, std::unique_lockbiraz daha fazla yük olabilir.

Bu günlerde std::scoped_lockyerine kullanmak gerektiğini unutmayın std::lock_guard.

lock_guardve unique_lockhemen hemen aynı şeydir; lock_guardsınırlı arayüzü olan kısıtlı bir versiyonudur.

A lock_guard, yapısından yıkımına kadar her zaman bir kilit tutar. A unique_lockhemen kilitlenmeden oluşturulabilir, var olduğu herhangi bir noktada kilidini açabilir ve kilidin sahipliğini bir örnekten diğerine aktarabilir.

Yani lock_guardyeteneklerine ihtiyacınız olmadığı sürece her zaman kullanırsınız unique_lock. A condition_variableihtiyaçları a unique_lock.

lock_guardEğer unlockaradaki muteksi yok etmeden elle yapabilmeniz gerekmedikçe kullanın lock.

Özellikle, condition_variableçağrılarda uyurken muteksinin kilidini açar wait. Bu yüzden a lock_guardburada yeterli değildir.

Arasında bazı ortak şeyler vardır lock_guardve unique_lockve bazı farklılıklara.

Ancak, sorulan soru bağlamında, derleyici lock_guardbir koşul değişkeni ile birlikte kullanılmasına izin vermez , çünkü bir iş parçacığı çağrıları bir koşul değişkenini beklediğinde, muteks otomatik olarak açılır ve diğer iş parçacığı / iş parçacıkları bildirildiğinde ve geçerli iş parçacığı çağrılır (beklemeden çıkar), kilit yeniden kazanılır.

Bu fenomen prensibine aykırıdır lock_guard. lock_guardsadece bir kez inşa edilebilir ve sadece bir kez yok edilebilir.

Bu nedenle lock_guardbir koşul değişkeni ile birlikte kullanılamaz, ancak a unique_lock( unique_lockbirkaç kez kilitlenip açılabilir) olabilir.

Gerçekten aynı muteksler değiller lock_guard<muType>, neredeyse aynıdırlar, std::mutexyaşamın kapsamın sonunda bittiği bir farkla (D-tor denir), bu iki muteks hakkında net bir tanım:

lock_guard<muType> bir kapsam bloğunun süresi boyunca muteks sahibi olmak için bir mekanizmaya sahiptir.

Ve

unique_lock<muType> ertelenmiş kilitleme, kilitleme için zaman kısıtlı girişimler, yinelemeli kilitleme, kilit sahipliğinin aktarılması ve koşul değişkenleriyle kullanıma izin veren bir sargıdır.

Örnek bir uygulama:

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

using namespace std::chrono;

class Product{

   public:

       Product(int data):mdata(data){
       }

       virtual~Product(){
       }

       bool isReady(){
       return flag;
       }

       void showData(){

        std::cout<<mdata<<std::endl;
       }

       void read(){

         std::this_thread::sleep_for(milliseconds(2000));

         std::lock_guard<std::mutex> guard(mmutex);

         flag = true;

         std::cout<<"Data is ready"<<std::endl;

         cvar.notify_one();

       }

       void task(){

       std::unique_lock<std::mutex> lock(mmutex);

       cvar.wait(lock, [&, this]() mutable throw() -> bool{ return this->isReady(); });

       mdata+=1;

       }

   protected:

    std::condition_variable cvar;
    std::mutex mmutex;
    int mdata;
    bool flag = false;

};

int main(){

     int a = 0;
     Product product(a);

     std::thread reading(product.read, &product);
     std::thread setting(product.task, &product);

     reading.join();
     setting.join();


     product.showData();
    return 0;
}

Bu örnekte, i kullanılan unique_lock<muType>ilecondition variable

Başkaları tarafından belirtildiği gibi, std :: unique_lock muteksin kilitli durumunu izler, böylece kilidin oluşturulmasından sonraya kadar kilitlemeyi erteleyebilir ve kilidin imha edilmesinden önce kilidini açabilirsiniz. std :: lock_guard buna izin vermiyor.

Std :: condition_variable wait işlevlerinin neden bir lock_guard yanı sıra unique_lock almaması için hiçbir neden yoktur, çünkü bir bekleme sona erdiğinde (hangi nedenle olursa olsun) muteks otomatik olarak yeniden alınır, böylece herhangi bir anlamsal ihlale neden olmaz. Ancak standarda göre, koşul değişkeni ile std :: lock_guard kullanmak için std :: condition_variable yerine std :: condition_variable_any kullanmanız gerekir.

Düzenleme : silindi "pthreads arabirimini kullanarak std :: condition_variable ve std :: condition_variable_any aynı olmalı". Gcc'nin uygulanmasına bakıldığında:

• std :: condition_variable :: wait (std :: unique_lock &), unique_lock tarafından tutulan muteks ile ilgili olarak altta yatan pthread koşulu değişkeninde pthread_cond_wait () 'i çağırır (ve böylece lock_guard için aynı şeyi yapabilir, ancak standart bunu sağlamaz)
• std :: condition_variable_any mutex kilidi olmayan biri de dahil olmak üzere herhangi bir kilitlenebilir nesne ile çalışabilir (bu nedenle süreçler arası semaforla bile çalışabilir)