System::Threading::Monitor sınıfı

Monitor class

Sınıf Monitor nesnelere erişimi senkronize eden bir mekanizma sağlar.

class Monitor : public System::Object

Yöntemler

YöntemAçıklama
static Enter(const SharedPtr<Object>&)Belirtilen nesne üzerinde ayrıcalıklı bir kilit alır.
static Enter(const System::SharedPtr<Object>&, bool&)Belirtilen nesne üzerinde ayrıcalıklı bir kilit alır ve kilidin alınıp alınmadığını gösteren bir değeri atomik olarak ayarlar.
static Exit(const SharedPtr<Object>&)Belirtilen nesne üzerindeki ayrıcalıklı kilidi serbest bırakır.
static IsEntered(const System::SharedPtr<Object>&)Mevcut iş parçacığının belirtilen nesne üzerindeki kilidi tutup tutmadığını belirler.
static Pulse(const SharedPtr<Object>&)Kilitli nesnenin durumundaki bir değişikliği bekleme kuyruğundaki bir iş parçacığına bildirir. Uygulanmadı.
static PulseAll(const SharedPtr<Object>&)Nesnenin durumundaki bir değişikliği tüm bekleyen iş parçacıklarına bildirir. Uygulanmadı.
static TryEnter(const SharedPtr<Object>&)Belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır. Uygulanmadı.
static TryEnter(const System::SharedPtr<Object>&, bool&)Belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır ve kilidin alınıp alınmadığını gösteren bir değeri atomik olarak ayarlar.
static TryEnter(const SharedPtr<Object>&, int32_t)Belirtilen milisaniye sayısı kadar süreyle belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır. Uygulanmadı.
static TryEnter(const SharedPtr<Object>&, TimeSpan)Belirtilen süre boyunca belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır. Uygulanmadı.
static TryEnter(const System::SharedPtr<Object>&, int32_t, bool&)Belirtilen süre boyunca, belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır ve kilidin alınıp alınmadığını gösteren bir değeri atomik olarak ayarlar.
static TryEnter(const System::SharedPtr<Object>&, TimeSpan, bool&)Belirtilen süre boyunca, belirtilen nesne üzerinde ayrıcalıklı bir kilit almaya çalışır ve kilidin alınıp alınmadığını gösteren bir değeri atomik olarak ayarlar.
static Wait(const SharedPtr<Object>&, int32_t, bool)Bir nesnedeki kilidi serbest bırakır ve mevcut iş parçacığını kilidi yeniden elde edene kadar engeller. Belirtilen zaman aşımı süresi dolarsa, iş parçacığı hazır kuyrukuna girer. İsteğe bağlı olarak, beklemeden önce senkronize bağlam için senkronizasyon alanından çıkar ve ardından alanı yeniden edinir. Uygulanmadı.
static Wait(const SharedPtr<Object>&, TimeSpan, bool)Bir nesnedeki kilidi serbest bırakır ve mevcut iş parçacığını kilidi yeniden elde edene kadar engeller. Belirtilen zaman aşımı süresi dolarsa, iş parçacığı hazır kuyrukuna girer. İsteğe bağlı olarak, beklemeden önce senkronize bağlam için senkronizasyon alanından çıkar ve ardından alanı yeniden edinir. Uygulanmadı.
static Wait(const SharedPtr<Object>&, int32_t)Bir nesnedeki kilidi serbest bırakır ve mevcut iş parçacığını kilidi yeniden elde edene kadar engeller. Belirtilen zaman aşımı süresi dolarsa, iş parçacığı hazır kuyrukuna girer. Uygulanmadı.
static Wait(const SharedPtr<Object>&, TimeSpan)Bir nesnedeki kilidi serbest bırakır ve mevcut iş parçacığını kilidi yeniden elde edene kadar engeller. Belirtilen zaman aşımı süresi dolarsa, iş parçacığı hazır kuyrukuna girer. Uygulanmadı.
static Wait(const SharedPtr<Object>&)Bir nesnedeki kilidi serbest bırakır ve mevcut iş parçacığını kilidi yeniden elde edene kadar engeller. Uygulanmadı.

Açıklamalar

#include "system/threading/monitor.h"
#include "system/threading/thread.h"
#include "system/smart_ptr.h"
#include "system/string.h"
#include <iostream>
#include <vector>

int main()
{
  using namespace System::Threading;

  const auto threadsCount = 3;
  std::cout << "Threads count: " << threadsCount << std::endl;
  auto locker = System::MakeObject<System::Object>();
  int x = 0;

  std::vector<System::SharedPtr<Thread>> threads;
  threads.reserve(threadsCount);
  for (auto i = 0; i < threadsCount; ++i)
  {
    threads.emplace_back(System::MakeObject<Thread>([&x, &locker]() -> void {
      Monitor::Enter(locker);

      x = 1;
      for (auto i = 0; i < 5; ++i)
      {
        std::cout << Thread::get_CurrentThread()->get_Name() << ": " << x++ << std::endl;
        Thread::Sleep(100);
      }

      Monitor::Exit(locker);
    }));
    threads.back()->set_Name(System::String("Thread " + std::to_string(i)));
    threads.back()->Start();
  }

  Thread::Sleep(threadsCount * 100);

  for (auto& thread : threads)
  {
    thread->Join();
  }

  return 0;
}
/*
This code example produces the following output:
Threads count: 3
Thread 0: 1
Thread 0: 2
Thread 0: 3
Thread 0: 4
Thread 0: 5
Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 2: 5
*/

Ayrıca Bakınız

System::Threading::ManualResetEvent sınıfı System::Threading::Mutex class