Lock Sınıfları

Otomatik Kilitleme Sınıfları
STL içindeki otomatik kilitleme için kullanılabilen iki sınıftan var. Bunlar std::lock_guard ve std::unique_lock.

1. lock_guard Sınıfı
std::lock_guard Sınıfı yazısına taşıdım.

2. unique_lock sınıfı
constructor tag'leri
Bu sınıf 3 tip constructor destekliyor.

unique_lock( mutex_type& m, std::defer_lock_t t );
unique_lock( mutex_type& m, std::try_to_lock_t t );
unique_lock( mutex_type& m, std::adopt_lock_t t );

Her tip aslında bir tag. Bu yönteme tag dispatching deniliyor. Tag için struct'lar şöyle tanımlanmış.

struct defer_lock_t { };
struct try_to_lock_t { };
struct adopt_lock_t { };

Tag'ler ise şöyle tanımlı

constexpr std::defer_lock_t defer_lock {};
constexpr std::try_to_lock_t try_to_lock {};
constexpr std::adopt_lock_t adopt_lock {};

boost ile benzerliği
Bu sınıf boost içindeli scoped_lock ile aynı. scoped_lock şöyle kullanılırdı.

boost::mutex::scoped_lock lock(_mutex, boost::try_to_lock);
if( lock ) {

}

constructor
Şöyle yaparız.

std::mutex m;
auto my_lock = std::unique_lock<std::mutex> (m);

Ya da şöyle  yaparız.

using mutex_type = std::mutex;
using lock_type = std::unique_lock<mutex_type>;

mutex_type m;

auto lock = lock_type(m);

operator boolean - Kilidi Kontrol Etme
Şöyle de yapabiliriz.

std::mutex mutex;
std::unique_lock<std::mutex> lock(mutex, std::try_to_lock);
if (lock) {
  ...
}

owns_lock metodu - Kilidi Kontrol Etme

Şimdiye kadar hiç bu metodu kullanmam gerekmedi. Kullanım yeri olarak aklıma şöyle bir örnek geliyor. Eğer bir thread periyodik çalışıyorsa ve bir başka thread tarafından engellenmek istemiyorsa mutex'i almayı dener. Başarırsa devam eder, başaramazsa bloke olmadan bir sonraki sefere denemek üzere başka bir iş yapar.

std::unique_lock<std::mutex> lock(initMutex, std::try_to_lock);
if(!lock.owns_lock())
{
  ...
}

unlock metodu
Destructor'dan önce kilidi bırakmak istersek şöyle yaparız.

lock.unlock();

3. std::lock metodu
std::lock metodu yazısına taşıdım

4. std::try_lock metodu
std::try_lock metodu yazısına taşıdım