信号和事件--事件篇

CreateEvent

OpenEvent

pthread_cond_init

sem_init

semget

semctl

与上下文相关

SetEvent

pthread_cond_signal

sem_post

semop

与上下文相关

ResetEvent

N/A

N/A

与上下文相关

WaitForSingleObject

pthread_cond_wait

pthread_cond_timedwait

sem_wait

sem_trywait

semop

与上下文相关

CloseHandle

pthread_cond_destroy

sem_destroy

semctl

与上下文相关

HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCTSTR lpName
)

HANDLE OpenEvent(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCTSTR lpName
)

int pthread_condattr_init(pthread_condattr_t *attr)
int pthread_condattr_destroy(pthread_condattr_t *attr)

DWORD WaitForSingleObject(
HANDLE hHandle,
DWORD dwMilliseconds
);

BOOL SetEvent(
HANDLE hEvent
)

int pthread_cond_signal(pthread_cond_t *cond)
int pthread_cond_broadcast(pthread_cond_t *cond)

BOOL ResetEvent(
HANDLE hEvent
);

BOOL CloseHandle(
HANDLE hObject
);

int sem_destroy(sem_t *sem)
int pthread_cond_destroy(pthread_cond_t *cond)

// Main thread
HANDLE hEvent; // Global Variable
// Thread 1
DWORD  dwRetCode;
// Create Event
hEvent = CreateEvent(
NULL,    // no security attributes
FALSE,   // Auto reset event
FALSE,   // initially set to non signaled state
NULL);   // un named event
// Wait for the event be signaled
dwRetCode = WaitForSingleObject(
hEvent,    // Mutex handle
INFINITE);   // Infinite wait
switch(dwRetCode) {
case WAIT_OBJECT_O :
// Event is signaled
// go ahead and proceed the work
default :
// Probe for error
}
// Completed the job,
// now close the event handle
CloseHandle(hEvent);
// Thread 2
// Condition met for the event hEvent
// now set the event
SetEvent(
hEvent);    // Event Handle

// Main thread
sem_t sem     ; // Global Variable
// Thread 1
int   retCode ;
// Initialize event semaphore
retCode = sem_init(
sem,   // handle to the event semaphore
0,     // not shared
0);    // initially set to non signaled state
// Wait for the event be signaled
retCode = sem_wait(
&sem); // event semaphore handle
// Indefinite wait
// Event Signaled
// a head and proceed the work
// Completed the job,
// now destroy the event semaphore
retCode = sem_destroy(
&sem);   // Event semaphore handle
// Thread 2
// Condition met
// now signal the event semaphore
sem_post(
&sem);    // Event semaphore Handle

// Main thread
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;
// Thread 1
...
pthread_mutex_lock(&mutex);
// signal one thread to wake up
pthread_cond_signal(&condvar);
pthread_mutex_unlock(&mutex);
// this signal is lost as no one is waiting
// Thread 1 now tries to take the mutex lock
// to send the signal but gets blocked
...
pthread_mutex_lock(&mutex);
// Thread 1 now gets the lock and can
// signal thread 2 to wake up
pthread_cond_signal(&condvar);
pthread_mutex_unlock(&mutex);
// Thread 2
pthread_mutex_lock(&mutex);
pthread_cond_wait(&condvar, &mutex);
pthread_mutex_unlock(&mutex);
// Thread 2 blocks indefinitely
// One way of avoiding losing the signal is as follows
// In Thread 2 - Lock the mutex early to avoid losing signal
pthread_mutex_lock (&mutex);
// Do work
.......
// This work may lead other threads to send signal to thread 2
// Thread 2 waits for indefinitely for the signal to be posted
pthread_cond_wait (&condvar, &Mutex );
// Thread 2 unblocks upon receipt of signal
pthread_mutex_unlock (&mutex);

// Process 1
DWORD  dwRetCode;
HANDLE hEvent; // Local variable
// Create Event
hEvent = CreateEvent(
NULL,        // no security attributes
FALSE,       // Auto reset event
FALSE,       // initially set to non signaled state
"myEvent");  // un named event
// Wait for the event be signaled
dwRetCode = WaitForSingleObject(
hEvent,    // Mutex handle
INFINITE);   // Infinite wait
switch(dwRetCode) {
case WAIT_OBJECT_O :
// Event is signaled
// go ahead and proceed the work
default :
// Probe for error
}
// Completed the job,
// now close the event handle
CloseHandle(hEvent);
// Process 2
HANDLE hEvent; // Local variable
// Open the Event
hEvent = CreateEvent(
NULL,        // no security attributes
FALSE,       // do not inherit handle
"myEvent");  // un named event
// Condition met for the event hEvent
// now set the event
SetEvent(
hEvent);    // Event Handle
// completed the job, now close the event handle
CloseHandle(hEvent);

// Process 1
int main()
{
//Definition of variables
key_t key;
int semid;
int Ret;
int timeout = 0;
struct sembuf operation[1] ;
union semun
{
int val;
struct semid_ds *buf;
USHORT *array;
} semctl_arg,ignored_argument;
key = ftok(); /Generate a unique key, U can also supply a value instead
semid = semget(key,                // a unique identifier to identify semaphore set
1,                // number of semaphore in the semaphore set
0666 | IPC_CREAT  // permissions (rwxrwxrwx) on the new
//     semaphore set and creation flag
);
if(semid < 0)
{
printf("Create semaphore set failed ");
Exit(1);
}
//Set Initial value for the resource - initially not owned
semctl_arg.val = 0; //Setting semval to 0
semctl(semid, 0, SETVAL, semctl_arg);
// wait on the semaphore
// blocked until it is signaled
operation[0].sem_op = -1;
operation[0].sem_num = 0;
operation[0].sem_flg = IPC_WAIT;
ret = semop(semid, operation,1);
// access the shared resource
...
...
//Close semaphore
iRc = semctl(semid, 1, IPC_RMID , ignored_argument);
}
// Process 2
int main()
{
key_t key = KEY; //Process 2 shd know key value in order to open the
// existing semaphore set
struct sembuf operation[1] ;
//Open semaphore
semid = semget(key, 1, 0);
// signal the semaphore by incrementing the semaphore count
operation[0].sem_op = 1;
operation[0].sem_num = 0;
operation[0].sem_flg = SEM_UNDO;
semop(semid, operation,0);
}