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

std::mutex Sınıfı

Giriş
Yeni mutex tipleri şunlar. Bu tipler POSIX'teki mutex tipleri ile aynı.

std::mutex, std::timed_mutex (C++11)
std::recursive_mutex, std::timed_recursive_mutex (C++11)
std::shared_mutex (C++17) , std::shared_timed_mutex (C++14)

Mutex Lockable kavramını getirir.

Mutex temel olarak şu metodları sunar.

• lock
• unlock
• try_lock

Windows'ta std::mutex
std::mutex Windows'ta altta CriticalSection ile gerçekleştirilmiş. Mutex içinde şöyle bir kod var.

struct _Mtx_internal_imp_t
{   /* Win32 mutex */
    int type; // here MS keeps particular mutex type
    Concurrency::critical_section cs;
    long thread_id;
    int count;
};

Aslında ne ile gerçekleştirilmiş olduğunun pek bir önemi yok. CriticalSection ve std::mutex farklı şeyler. CriticalSection aynı thread tarafından birden fazla kilitlenebilir. Yani recursive bir yapıdır. std::mutex ise sadece bir kere kilitlenebilir.

try_lock metodu
Bu metodu hiç bir zaman kullanmamak en iyisi. unique_lock kullanmak en güzel çözüm.

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

Şöyle kullanılırsa çok fazla işlemci yer.

std::mutex m;
while (!m.try_lock()) {}
# do work
m.unlock();