Lock::try_acquire

Adquire um bloqueio de um objeto, aguardando um período de tempo especificado e retornando um bool para relatar o sucesso da aquisição em vez de gerar uma exceção.

bool try_acquire(
   int _timeout_ms
);
bool try_acquire(
   System::TimeSpan _timeout
);

Parâmetros

• _timeout
  Valor de tempo limite em milissegundos ou como um TimeSpan.

Valor de retorno

trueSe o bloqueio tiver sido adquirido, false contrário.

Comentários

Se já tiver sido adquirido um bloqueio, essa função não faz nada.

Exemplo

Este exemplo usa uma única instância de uma classe por vários threads.A classe usa um bloqueio no próprio para garantir que os acessos a seus dados internos consistentes para cada segmento.O thread principal do aplicativo usa um bloqueio na mesma instância da classe para verificar periodicamente se os threads de trabalho ainda existem e aguarda sair até que todos os threads de trabalho concluíram suas tarefas.

// msl_lock_try_acquire.cpp
// compile with: /clr
#include <msclr/lock.h>

using namespace System;
using namespace System::Threading;
using namespace msclr;

ref class CounterClass {
private:
   int Counter;   

public:
   property int ThreadCount;

   // function called by multiple threads, use lock to keep Counter consistent
   // for each thread
   void UseCounter() {
      try {
         lock l(this); // wait infinitely

         Console::WriteLine("In thread {0}, Counter = {1}", Thread::CurrentThread->ManagedThreadId, 
            Counter);

         for (int i = 0; i < 10; i++) {
            Counter++;
            Thread::Sleep(10);
         }
         
         Console::WriteLine("In thread {0}, Counter = {1}", Thread::CurrentThread->ManagedThreadId, 
            Counter);

         Counter = 0;
         // lock is automatically released when it goes out of scope and its destructor is called
      }
      catch (...) {
         Console::WriteLine("Couldn't acquire lock!");
      }

      ThreadCount--;
   }
};

int main() {
   // create a few threads to contend for access to the shared data
   CounterClass^ cc = gcnew CounterClass;
   array<Thread^>^ tarr = gcnew array<Thread^>(5);
   ThreadStart^ startDelegate = gcnew ThreadStart(cc, &CounterClass::UseCounter);
   for (int i = 0; i < tarr->Length; i++) {
      tarr[i] = gcnew Thread(startDelegate);
      cc->ThreadCount++;
      tarr[i]->Start();
   }

   // keep our main thread alive until all worker threads have completed
   lock l(cc, lock_later); // don't lock now, just create the object
   while (true) {
      if (l.try_acquire(50)) { // try to acquire lock, don't throw an exception if can't
         if (0 == cc->ThreadCount) {
            Console::WriteLine("All threads completed.");
            break; // all threads are gone, exit while
         }
         else {
            Console::WriteLine("{0} threads exist, continue waiting...", cc->ThreadCount);
            l.release(); // some threads exist, let them do their work
         }
      }
   }
}

Requisitos

Arquivo de cabeçalho <msclr\lock.h>

Namespace msclr

Consulte também

Referência

Lock::acquire

Outros recursos

Bloquear membros