将 Windows IPC 应用程序移植到 Linux，第 2 部分: 信号量和事件

互斥

互斥 － pthread 库

System V 信号量

临界区

互斥 － pthread 库

不适用，因为临界区只用于同一进程的不同线程之间

信号量

具有互斥的条件变量 － pthreads

POSIX 信号量

System V 信号量

事件

具有互斥的条件变量 － pthreads

System V 信号量

CreateSemaphore

sem_init

semget

semctl

与上下文相关

OpenSemaphore

不适用

semget

与上下文相关

WaitForSingleObject

sem_wait

sem_trywait

semop

与上下文相关

ReleaseSemaphore

sem_post

semop

与上下文相关

CloseHandle

sem_destroy

semctl

与上下文相关

HANDLE CreateSemaphore(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName
);

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

BOOL ReleaseSemaphore(
HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lpPreviousCount
);

BOOL CloseHandle(
HANDLE hObject
);

HANDLE hSemaphore;
LONG   lCountMax = 10;
LONG   lPrevCount;
DWORD  dwRetCode;
// Create a semaphore with initial and max. counts of 10.
hSemaphore = CreateSemaphore(
NULL,        // no security attributes
0,           // initial count
lCountMax,   // maximum count
NULL);       // unnamed semaphore
// Try to enter the semaphore gate.
dwRetCode = WaitForSingleObject(
hSemaphore,  // handle to semaphore
2000L);   // zero-second time-out interval
switch (dwRetCode)
{
// The semaphore object was signaled.
case WAIT_OBJECT_0:
// Semaphore is signaled
// go ahead and continue the work
goto success:
break;
case WAIT_TIMEOUT:
// Handle the time out case
break;
}
Success:
// Job done, release the semaphore
ReleaseSemaphore(
hSemaphore,  // handle to semaphore
1,           // increase count by one
NULL)        // not interested in previous count
// Close the semaphore handle
CloseHandle(hSemaphore);

// Main thread
#define TIMEOUT 200  /* 2 secs */
// Thread 1
sem_t sem     ; // Global Variable
int   retCode ;
// Initialize event semaphore
retCode = sem_init(
sem,   // handle to the event semaphore
0,     // not shared
0);    // initially set to non signaled state
while (timeout < TIMEOUT ) {
delay.tv_sec = 0;
delay.tv_nsec = 1000000;  /* 1 milli sec */
// Wait for the event be signaled
retCode = sem_trywait(
&sem); // event semaphore handle
// non blocking call
if (!retCode)  {
/* Event is signaled */
break;
}
else {
/* check whether somebody else has the mutex */
if (retCode == EPERM ) {
/* sleep for delay time */
nanosleep(&delay, NULL);
timeout++ ;
}
else{
/* error  */
}
}
}
// 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

// Process 1
#define TIMEOUT 200
//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
);
//Set Initial value for the resource
semctl_arg.val = 0; //Setting semval to 0
semctl(semid, 0, SETVAL, semctl_arg);
//Wait for Zero
while(timeout < TIMEOUT)
{
delay.tv_sec = 0;
delay.tv_nsec = 1000000;  /* 1 milli sec */
//Call Wait for Zero with IPC_NOWAIT option,so it will be non blocking
operation[0].sem_op = -1; // Wait until the semaphore count becomes 0
operation[0].sem_num = 0;
operation[0].sem_flg = IPC_NOWAIT;
ret = semop(semid, operation,1);
if(ret < 0)
{
/* check whether somebody else has the mutex */
if (retCode == EPERM )
{
/* sleep for delay time */
nanosleep(&delay, NULL);
timeout++ ;
}
else
{
printf("ERROR while wait ");
break;
}
}
else
{
/*semaphore got triggered */
break;
}
}
//Close semaphore
iRc = semctl(semid, 1, IPC_RMID , ignored_argument);
}
// Process 2
key_t key = KEY; // Process 2 should know key value in order to open the
//    existing semaphore set
struct sembuf operation[1] ;
//Open semaphore
semid = semget(key, 1, 0);
operation[0].sem_op = 1; // Release the resource so Wait in process 1 will
//    be triggered
operation[0].sem_num = 0;
operation[0].sem_flg = SEM_UNDO;
//Release semaphore
semop(semid, operation,0);
}

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);
}