#ifndef __LOCK
#define __LOCK
class Lock
{
public:
virtual void lock() = 0;
virtual void unlock() = 0;
};
#endif
===========================================================
#include <windows.h>
#include "Lock.hpp"
#ifndef _EVENT_LOCK
#define _EVENT_LOCK
class EventLock : public Lock
{
private:
HANDLE event;
public:
EventLock();
EventLock(const char* name);
virtual void lock();
void lock(HANDLE event);
virtual void unlock();
void unlock(HANDLE event);
HANDLE getEvent();
};
#endif
============================================================
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include "log.h"
#include "EventLock.hpp"
EventLock::EventLock()
{
this->event = CreateEvent(NULL, FALSE, TRUE, NULL);
if (this->event == NULL)
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
debug("EventLock()");
}
EventLock::EventLock(const char* name)
{
this->event = CreateEvent(NULL, FALSE, FALSE, name);
if (this->event == NULL)
{
DWORD error = GetLastError();
warn("create event error %d", error);
}
else
{
DWORD error = GetLastError();
if (error == ERROR_ALREADY_EXISTS)
{
debug("event name %s already exists, use the existed event instead.", name);
}
}
}
void EventLock::lock()
{
lock(this->event);
}
void EventLock::lock(HANDLE event)
{
DWORD e = WaitForSingleObject(event, INFINITE);
if (e == WAIT_FAILED)
{
DWORD error = GetLastError();
warn("wait error %d", error);
}
else if(e == WAIT_TIMEOUT)
{
debug("wait time out");
}
else if(e == WAIT_ABANDONED)
{
debug("wait abandoned");
}
}
void EventLock::unlock()
{
this->unlock(this->event);
}
void EventLock::unlock(HANDLE event)
{
BOOL isr = SetEvent(this->event);
if (! isr)
{
DWORD error = GetLastError();
warn("release event error %d", error);
}
}
HANDLE EventLock::getEvent()
{
return this->event;
}
================================================================
#define _WIN32_WINNT 0x0400
#include <stdio.h>
#include <windows.h>
#include "../Lock.hpp"
#include "../EventLock.hpp"
#include "../Thread.hpp"
#ifndef TEST_EVENT_LOCK_MESSAGE_DESTINATION
#define TEST_EVENT_LOCK_MESSAGE_DESTINATION
class TestEventLockMessageDestination
{
private:
Lock *lock;
//HANDLE hEvent;
int i;
public:
TestEventLockMessageDestination()
{
lock = new EventLock();
//hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
i = 0;
}
void add()
{
lock->lock();
i++;
printf("[Producer] message %d\n", this->i);
/*
if (i > 0)
{
SetEvent(hEvent);
}
*/
lock->unlock();
}
void reduce()
{
lock->lock();
/*
if (i <= 0)
{
ResetEvent(hEvent);
WaitForSingleObject(hEvent, INFINITE);
}
*/
i--;
printf("[Consumer] message %d\n", i);
lock->unlock();
}
};
#endif
==============================================================
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
#ifndef TEST_EVENT_LOCK_MESSAGE_PRODUCER
#define TEST_EVENT_LOCK_MESSAGE_PRODUCER
class TestEventLockMessageProducer : public Thread
{
private:
TestEventLockMessageDestination *destination;
public:
TestEventLockMessageProducer()
{
this->destination = NULL;
}
void registerProducer(TestEventLockMessageDestination *destination)
{
this->destination = destination;
}
void run()
{
while (1)
{
if (destination != NULL)
{
destination->add();
}
Sleep(5000);
}
}
};
#endif
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#include <stdio.h>
#include "../Thread.hpp"
#include "TestEventLockMessageDestination.hpp"
#ifndef TEST_EVENT_LOCK_MESSAGE_CONSUMER
#define TEST_EVENT_LOCK_MESSAGE_CONSUMER
class TestEventLockMessageConsumer : public Thread
{
private:
TestEventLockMessageDestination *destination;
public:
TestEventLockMessageConsumer()
{
this->destination = NULL;
}
void registerConsumer(TestEventLockMessageDestination *destination)
{
this->destination = destination;
}
void run()
{
while (1)
{
if (destination != NULL)
{
this->destination->reduce();
}
Sleep(500);
}
}
};
#endif
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#include "TestEventLockMessageDestination.hpp"
#include "TestEventLockMessageProducer.hpp"
#include "TestEventLockMessageConsumer.hpp"
void main()
{
///*
TestEventLockMessageDestination *destination = new TestEventLockMessageDestination();
TestEventLockMessageProducer *producer = new TestEventLockMessageProducer();
producer->registerProducer(destination);
producer->start();
TestEventLockMessageConsumer *consumer = new TestEventLockMessageConsumer();
consumer->registerConsumer(destination);
consumer->start();
/*
while(1)
{
Sleep(2000);
}
*/
ExitThread(0);
/*
DWORD threadID;
CreateThread(NULL, 0, Callback1, (LPVOID) NULL, 0, &threadID);
printf("Thread %ld started...\n", threadID);
CreateThread(NULL, 0, Callback2, (LPVOID) NULL, 0, &threadID);
printf("Thread %ld started...\n", threadID);
ExitThread(0);
*/
}