Clase System::Threading::Monitor

Monitor class

La clase Monitor proporciona un mecanismo que sincroniza el acceso a objetos.

class Monitor : public System::Object

Métodos

MétodoDescripción
static Enter(const SharedPtr<Object>&)Adquiere un bloqueo exclusivo en un objeto especificado.
static Enter(const System::SharedPtr<Object>&, bool&)Adquiere un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si el bloqueo fue tomado.
static Exit(const SharedPtr<Object>&)Libera un bloqueo exclusivo en el objeto especificado.
static IsEntered(const System::SharedPtr<Object>&)Determina si el hilo actual posee el bloqueo en el objeto especificado.
static Pulse(const SharedPtr<Object>&)Notifica a un hilo en la cola de espera sobre un cambio en el estado del objeto bloqueado. No implementado.
static PulseAll(const SharedPtr<Object>&)Notifica a todos los hilos en espera sobre un cambio en el estado del objeto. No implementado.
static TryEnter(const SharedPtr<Object>&)Intenta adquirir un bloqueo exclusivo en el objeto especificado. No implementado.
static TryEnter(const System::SharedPtr<Object>&, bool&)Intenta adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si el bloqueo fue tomado.
static TryEnter(const SharedPtr<Object>&, int32_t)Intenta, durante el número especificado de milisegundos, adquirir un bloqueo exclusivo en el objeto especificado. No implementado.
static TryEnter(const SharedPtr<Object>&, TimeSpan)Intenta, durante el tiempo especificado, adquirir un bloqueo exclusivo en el objeto especificado. No implementado.
static TryEnter(const System::SharedPtr<Object>&, int32_t, bool&)Intenta, durante el tiempo especificado, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se tomó el bloqueo.
static TryEnter(const System::SharedPtr<Object>&, TimeSpan, bool&)Intenta, durante el tiempo especificado, adquirir un bloqueo exclusivo en el objeto especificado y establece de forma atómica un valor que indica si se tomó el bloqueo.
static Wait(const SharedPtr<Object>&, int32_t, bool)Libera el bloqueo de un objeto y bloquea el hilo actual hasta que vuelva a adquirir el bloqueo. Si transcurre el intervalo de tiempo de espera especificado, el hilo entra en la cola de listos. Opcionalmente sale del dominio de sincronización para el contexto sincronizado antes de la espera y vuelve a adquirir el dominio después. No implementado.
static Wait(const SharedPtr<Object>&, TimeSpan, bool)Libera el bloqueo de un objeto y bloquea el hilo actual hasta que vuelva a adquirir el bloqueo. Si transcurre el intervalo de tiempo de espera especificado, el hilo entra en la cola de listos. Opcionalmente sale del dominio de sincronización para el contexto sincronizado antes de la espera y vuelve a adquirir el dominio después. No implementado.
static Wait(const SharedPtr<Object>&, int32_t)Libera el bloqueo de un objeto y bloquea el hilo actual hasta que vuelva a adquirir el bloqueo. Si transcurre el intervalo de tiempo de espera especificado, el hilo entra en la cola de listos. No implementado.
static Wait(const SharedPtr<Object>&, TimeSpan)Libera el bloqueo de un objeto y bloquea el hilo actual hasta que vuelva a adquirir el bloqueo. Si transcurre el intervalo de tiempo de espera especificado, el hilo entra en la cola de listos. No implementado.
static Wait(const SharedPtr<Object>&)Libera el bloqueo de un objeto y bloquea el hilo actual hasta que vuelva a adquirir el bloqueo. No implementado.

Observaciones

#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
*/

Ver también

System::Threading::ManualResetEvent clase System::Threading::Mutex class