CEvent 클래스

아티클
06/10/2015

한 스레드가 다른 스레드에게 이벤트가 발생 했음을 알리기 위해 사용 하는 동기화 개체인 이벤트를 나타냅니다.

class CEvent : public CSyncObject

Members

Public 생성자

Name	설명
CEvent::CEvent	CEvent 개체를 생성합니다.

Public 메서드

Name	설명
CEvent::PulseEvent	설정 이벤트를 사용 가능 (신호)를 대기 스레드를 해제 하 고 이벤트를 사용할 수 없게 합니다 (nonsignaled) 설정.
CEvent::ResetEvent	이벤트에 사용할 수 없습니다 (nonsignaled) 설정합니다.
CEvent::SetEvent	이벤트에 사용할 수 있는 (신호) 설정 하 고 모든 대기 스레드를 해제 합니다.
CEvent::Unlock	이벤트 개체를 해제합니다.

설명

이벤트 스레드는 해당 작업을 수행 하는 경우 알아야 할 때 유용 합니다. 예를 들어, 스레드가 데이터를 데이터 보관 저장소에 복사 하는 새 데이터를 사용할 수 있을 때 알림을 받아야 합니다. 사용 하는 CEvent 개체에서 새 데이터를 사용할 때 복사 스레드를 알리기 위해 스레드가 해당 작업을 빨리 수행할 수 있습니다.

CEvent개체 유형에 있습니다: 수동 및 자동.

자동 CEvent 개체를 자동으로 반환 아닌 신호 (사용할 수 없음) 상태에 적어도 하나의 스레드를 해제 한 후. 기본적으로 CEvent 개체인 자동 전달 하지 않으면 TRUE 에 있는 bManualReset 매개 변수가 생성 되는 동안.

수동 CEvent 개체를 유지 하는 상태로 설정 하 SetEvent 또는 ResetEvent 다른 함수를 호출할 때까지. 수동으로 만들려면 CEvent 개체, 전달 TRUE 에 있는 bManualReset 매개 변수가 생성 되는 동안.

사용 하는 CEvent 개체, 구성 된 CEvent 필요할 때 개체. 대기 신청이 처음이 소유 해야 하는 지정 하려는 이벤트의 이름을 지정 합니다. 그런 다음 생성자는 반환 될 때 이벤트를 액세스할 수 있습니다. 호출 SetEvent 신호 (오프) 이벤트 개체 및 다음 호출 잠금 해제 완료 되 면 제어 된 리소스에 액세스 합니다.

사용 하는 또 다른 방법은 CEvent 개체는 형식의 변수를 추가 하려면 CEvent 컨트롤에 클래스를 데이터 멤버로. 제어 개체 생성 시 생성자의 호출을 CEvent 데이터 멤버 여부 이벤트가 처음 신호, 및 specifythe 형식의 원하는 이벤트 개체 (프로세스 경계에 걸쳐 사용 되는 경우)에 이벤트의 이름 지정 하 고 모든 보안 특성을.

제어 된 리소스에 액세스 하는 CEvent 개체를이 이런 식으로, 처음 두 형식의 변수를 만들 CSingleLock 또는 형식 CMultiLock 리소스 액세스 방법에서. 다음 호출에서 Lock 잠금 개체의 메서드 (예를 들어, CMultiLock::Lock). 이 스레드가 됩니다 중 리소스, 출시 하 고 액세스, 리소스 해제 대기 리소스에 대 한 대기 시간 초과 대 한 액세스 및 리소스에 액세스할 수 없습니다. 스레드로부터 안전한 방식으로 리소스에 액세스 한 경우에. 리소스를 해제 하려면 호출 SetEvent 이벤트 개체를 신호 하 고 사용 하는 Unlock 잠금 개체의 메서드 (예를 들어, CMultiLock::Unlock), 또는 잠금 개체가 범위를 벗어난 수 있습니다.

사용 하는 방법에 대 한 자세한 내용은 CEvent 개체를 참조 하십시오. 다중 스레딩: 동기화 클래스 사용 방법.

예제

// The following demonstrates trivial usage of the CEvent class. 
// A CEvent object is created and passed as a parameter to another  
// thread.  The other thread will wait for the event to be signaled 
// and then exit

UINT __cdecl MyThreadProc(LPVOID lpParameter)
{
   CEvent* pEvent = (CEvent*)(lpParameter);
   VERIFY(pEvent != NULL);

   // Wait for the event to be signaled
   ::WaitForSingleObject(pEvent->m_hObject, INFINITE);

   // Terminate the thread
   ::AfxEndThread(0, FALSE); 
   return 0L;
}

void CEvent_Test()
{
   // Create the CEvent object that will be passed to the thread routine
   CEvent* pEvent = new CEvent(FALSE, FALSE);

   // Create a thread that will wait on the event
   CWinThread* pThread;
   pThread = ::AfxBeginThread(&MyThreadProc, pEvent, 0, 0, CREATE_SUSPENDED, NULL);
   pThread->m_bAutoDelete = FALSE; 
   pThread->ResumeThread();

   // Signal the thread to do the next work item
   pEvent->SetEvent();

   // Wait for the thread to consume the event and return
   ::WaitForSingleObject(pThread->m_hThread, INFINITE); 
   delete pThread;
   delete pEvent;
}

// This example builds upon the previous one. 
// A second thread is created to calculate prime numbers. 
// The main thread will signal the second thread to calulate the next  
// prime number in the series.  The second thread signals the first  
// after each number is calculated. Finally, after several iterations  
// the worker thread is signaled to terminate. 

class CPrimeTest
{
public:
   CPrimeTest()
      : m_pCalcNext(new CEvent(FALSE, FALSE))
      , m_pCalcFinished(new CEvent(FALSE, FALSE))
      , m_pTerminateThread(new CEvent(FALSE, FALSE))
      , m_iCurrentPrime(0)
   {   
      // Create a thread that will calculate the prime numbers
      CWinThread* pThread;
      pThread = ::AfxBeginThread(&PrimeCalcProc, this, 0, 0, CREATE_SUSPENDED, NULL);
      pThread->m_bAutoDelete = FALSE; 
      pThread->ResumeThread();

      // Calcuate the first 10 prime numbers in the series on the thread 
      for(UINT i = 0; i < 10; i++)
      {
         // Signal the thread to do the next work item
         m_pCalcNext->SetEvent();
         // Wait for the thread to complete the current task
         ::WaitForSingleObject(m_pCalcFinished->m_hObject, INFINITE);
         // Print the result
         TRACE(_T("The value of m_iCurrentPrime is: %d\n"), m_iCurrentPrime);
      }

      // Notify the worker thread to exit and wait for it to complete
      m_pTerminateThread->SetEvent();
      ::WaitForSingleObject(pThread->m_hThread, INFINITE); 
      delete pThread;
   }
   ~CPrimeTest()
   {
      delete m_pCalcNext;
      delete m_pCalcFinished;
      delete m_pTerminateThread;
   }

private:
   // Determines whether the given number is a prime number 
   static BOOL IsPrime(INT ThisPrime)
   {
      if(ThisPrime < 2) 
         return FALSE;

      for(INT n = 2; n < ThisPrime; n++)
      {
         if(ThisPrime % n == 0)
            return FALSE;
      }
      return TRUE;
   }

   // Calculates the next prime number in the series 
   static INT NextPrime(INT ThisPrime)
   {
      while(TRUE)
      {
         if(IsPrime(++ThisPrime))
         {
            return ThisPrime;
         }
      }
   }

   // Worker thread responsible for calculating the next prime 
   // number in the series 
   static UINT __cdecl PrimeCalcProc(LPVOID lpParameter)
   {
      CPrimeTest* pThis = static_cast<CPrimeTest*>(lpParameter);
      VERIFY(pThis != NULL);

      VERIFY(pThis->m_pCalcNext != NULL);
      VERIFY(pThis->m_pCalcFinished != NULL);
      VERIFY(pThis->m_pTerminateThread != NULL);

      // Create a CMultiLock object to wait on the various events 
      // WAIT_OBJECT_0 refers to the first event in the array, WAIT_OBJECT_0+1 refers to the second
      CSyncObject* pWaitObjects[] = { pThis->m_pCalcNext, pThis->m_pTerminateThread };
      CMultiLock MultiLock(pWaitObjects, 2L);
      while(MultiLock.Lock(INFINITE, FALSE) == WAIT_OBJECT_0) 
      {         
         // Calculate next prime
         pThis->m_iCurrentPrime = NextPrime(pThis->m_iCurrentPrime);
         // Notify main thread calculation is complete
         pThis->m_pCalcFinished->SetEvent();
       } 

      // Terminate the thread
       ::AfxEndThread(0, FALSE); 
      return 0L;
   }

   CEvent* m_pCalcNext;      // notifies worker thread to calculate next prime
   CEvent* m_pCalcFinished;   // notifies main thread current calculation is complete
   CEvent* m_pTerminateThread;   // notifies worker thread to terminate

   INT m_iCurrentPrime;   // current calculated prime number
};