linux 命名信号量实现进程间的互斥与同步

/* 
   命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt 
   int sem_wait(sem_t *sem); //P操作,若是信号量大于零则减一,否则阻塞在该函数位置等待. 
   int sem_post(sem_t *sem); //V操作,信号量加一 
   sem_t *sem_open(const char *name, int oflag);//打开信号量,flag参数与打开普通文件的标记一样 
   sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value); 
 //创建并打开信号量,value参数指的是信号量的初始值 
int sem_unlink(const char *name);//删除系统创建的信号量 
int sem_close(sem_t *sem);//关闭彻底销毁信号量 
 */ 

[文件] sem_dan_syn.c ~ 2KB    下载(68)

01	#include <stdio.h>

02	#include <errno.h>

03	#include <semaphore.h>

04	#include <fcntl.h>

05

06

/*

07	命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt

08	int sem_wait(sem_t *sem); //P操作,若是信号量大于零则减一,否则阻塞在该函数位置等待.

09	int sem_post(sem_t *sem); //V操作,信号量加一

10	sem_t *sem_open(const char *name, int oflag);//打开信号量,flag参数与打开普通文件的标记一样

11	sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

12	//创建并打开信号量,value参数指的是信号量的初始值

13	int sem_unlink(const char *name);//删除系统创建的信号量

14	int sem_close(sem_t *sem);//关闭彻底销毁信号量

15

*/

16

17

/*进程排斥*/

18

19	#define SEM_NAME "mysem"

20	#define OPEN_FLAG O_RDWR|O_CREAT

21	#define OPEN_MODE 00777

22	#define INIT_V    0

23	static sem_t *sem = NULL;

24

25	static void mysem(char *str)

26

{

27	int i = 0;

28	while('\0' != str[i])

29

{

30	printf("%c\n", str[i++]);

31

sleep(1);

32

}

33

}

34

35

36	/*单次同步, 把信号量先初始化为0*/

37

38	int main(void)

39

{

40

41	pid_t pid = -1;

42	int ret = -1;

43	int status = -1;

44

45	//创建一个命名信号量

46	sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V);

47

48

//创建子进程

49	pid = fork();

50	if(-1 == (ret = pid))

51

{

52	perror("fork failed: ");

53	goto _OUT;

54

}

55

56	if(0 == pid)

57

{

58	mysem("abcd");

59

//V操作

60	sem_post(sem);

61

}

62

63	if(0 < pid)

64

{

65

//P操作

66	sem_wait(sem);

67	mysem("1234");

68

//等待子进程结束

69	wait(&status);

70	//删掉在系统创建的信号量

71	sem_unlink(SEM_NAME);

72	//彻底销毁打开的信号量

73	sem_close(sem);

74

}

75

76

_OUT:

77	return ret;

78

}

[文件] sem_diedai_syn.c ~ 2KB    下载(42)

001	#include <stdio.h>

002	#include <errno.h>

003	#include <semaphore.h>

004	#include <fcntl.h>

005	#include <signal.h>

006

007

/*

008	命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt

009	int sem_wait(sem_t *sem); //P操作,若是信号量大于零则减一,否则阻塞在该函数位置等待.

010	int sem_post(sem_t *sem); //V操作,信号量加一

011	sem_t *sem_open(const char *name, int oflag);//打开信号量,flag参数与打开普通文件的标记一样

012	sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

013	//创建并打开信号量,value参数指的是信号量的初始值

014	int sem_unlink(const char *name);//删除系统创建的信号量

015	int sem_close(sem_t *sem);//关闭彻底销毁信号量

016

*/

017

018	#define SEM_NAME1 "mysem1"

019	#define SEM_NAME2 "mysem2"

020	#define OPEN_FLAG O_RDWR|O_CREAT

021	#define OPEN_MODE 00777

022

023	static sem_t *sem1 = NULL;

024	static sem_t *sem2 = NULL;

025

026

//临界区

027	static void mysem(char *str)

028

{

029	int i = 0;

030	while('\0' != str[i])

031

{

032	printf("%c\n", str[i++]);

033

sleep(1);

034

}

035

}

036

//信号捕捉处理

037	static void myhandler(void)

038

{

039	//删掉在系统创建的信号量

040	sem_unlink(SEM_NAME1);

041	sem_unlink(SEM_NAME2);

042	//彻底销毁打开的信号量

043	sem_close(sem1);

044	sem_close(sem2);

045

}

046

047

048	/*迭代同步,两个信号量，开始时一个为1，一个为0， 一个进程执行完换另一个进程运行*/

049

050	int main(void)

051

{

052

053	pid_t pid = -1;

054	int ret = -1;

055	int status = -1;

056

057

//安装捕捉信号

058	signal(SIGINT,(void *)myhandler );

059

060	//创建一个命名信号量

061	sem1 = sem_open(SEM_NAME1, OPEN_FLAG, OPEN_MODE, 1);

062	sem2 = sem_open(SEM_NAME2, OPEN_FLAG, OPEN_MODE, 0);

063

064

//创建子进程

065	pid = fork();

066	if(-1 == (ret = pid))

067

{

068	perror("fork failed: ");

069	goto _OUT;

070

}

071

072	if(0 == pid)

073

{

074

while(1)

075

{

076

//P操作

077	sem_wait(sem1);

078	mysem("abcd");

079

//V操作

080	sem_post(sem2);

081

}

082

}

083

084	if(0 < pid)

085

{

086

while(1)

087

{

088

//P操作

089	sem_wait(sem2);

090	mysem("1234");

091

//V操作

092	sem_post(sem1);

093

}

094

//等待子进程结束

095	wait(&status);

096

}

097

098

_OUT:

099	return ret;

100

}

[文件] sem_paichi.c ~ 2KB    下载(51)

01	#include <stdio.h>

02	#include <errno.h>

03	#include <semaphore.h>

04	#include <fcntl.h>

05

06

/*

07	命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt

08	int sem_wait(sem_t *sem); //P操作,若是信号量大于零则减一,否则阻塞在该函数位置等待.

09	int sem_post(sem_t *sem); //V操作,信号量加一

10	sem_t *sem_open(const char *name, int oflag);//打开信号量,flag参数与打开普通文件的标记一样

11	sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);

12	//创建并打开信号量,value参数指的是信号量的初始值

13	int sem_unlink(const char *name);//删除系统创建的信号量

14	int sem_close(sem_t *sem);//关闭彻底销毁信号量

15

*/

16

17

18	#define SEM_NAME "mysem"

19	#define OPEN_FLAG O_RDWR|O_CREAT

20	#define OPEN_MODE 00777

21	#define INIT_V    1

22	static sem_t *sem = NULL;

23

24	static void mysem(char *str)

25

{

26	int i = 0;

27

//P操作

28	sem_wait(sem);

29	while('\0' != str[i])

30

{

31	printf("%c\n", str[i++]);

32

sleep(1);

33

}

34

//V操作

35	sem_post(sem);

36

}

37

38

39	/*进程排斥,在临界区设置PV操作*/

40

41	int main(void)

42

{

43

44	pid_t pid = -1;

45	int ret = -1;

46	int status = -1;

47

48	//创建一个命名信号量

49	sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V);

50

51

//创建子进程

52	pid = fork();

53	if(-1 == (ret = pid))

54

{

55	perror("fork failed: ");

56	goto _OUT;

57

}

58

59	if(0 == pid)

60

{

61	mysem("abcd");

62

}

63

64	if(0 < pid)

65

{

66	mysem("1234");

67

//等待子进程结束

68	wait(&status);

69	//删掉在系统创建的信号量

70	sem_unlink(SEM_NAME);

71	//彻底销毁打开的信号量

72	sem_close(sem);

73

}

74

75

_OUT:

76	return ret;

77

}