Unix IPC之基于共享内存的计数器

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#include <sys/mman>

/**

 * Map addresses starting near ADDR and extending for LEN bytes.

 * from OFFSET into the file FD describes according to PROT and FLAGS.

 * If ADDR is nonzero, it is the desired mapping address.

 * If the MAP_FIXED bit is set in FLAGS, the mapping will be at ADDR exactly (which must be

 * page-aligned); otherwise the system chooses a convenient nearby address.

 * The return value is the actual mapping address chosen or MAP_FAILED

 * for errors (in which case `errno‘ is set).  A successful `mmap‘ call

 * deallocates any previous mapping for the affected region.

 */

void *mmap (void *__addr, size_t __len, int __prot,

            int __flags, int __fd, __off_t __offset);

/* Deallocate any mapping for the region starting at ADDR and extending LEN

   bytes.  Returns 0 if successful, -1 for errors (and sets errno).  */

extern int munmap (void *__addr, size_t __len) __THROW;

/* Synchronize the region starting at ADDR and extending LEN bytes with the

   file it maps.  Filesystem operations on a file being mapped are

   unpredictable before this is done.  Flags are from the MS_* set.

   This function is a cancellation point and therefore not marked with

   __THROW.  */

extern int msync (void *__addr, size_t __len, int __flags);

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

#include    "unpipc.h"

#define SEM_NAME    "mysem"

int     count = 0; // 计数器

int main(int argc, char **argv)

{

    int     i, nloop;

    sem_t   *mutex;

    if (argc != 2)

        err_quit("usage: incr1 <#loops>");

    nloop = atoi(argv[1]);

    /* 4create, initialize, and unlink semaphore */

    mutex = Sem_open(Px_ipc_name(SEM_NAME), O_CREAT | O_EXCL, FILE_MODE, 1);

    /**

     * sem_unlink() 

     * removes the named semaphore referred to by name. 

     * The semaphore name is removed immediately. 

     * The semaphore is destroyed once all other processes that have the semaphore open close it.

     */

    Sem_unlink(Px_ipc_name(SEM_NAME));

    // 非缓冲模式，防止两个线程的输出交叉

    // 父子线程共同访问一个信号量

    // 由于mutex是2值信号量，相当于同步父子线程

    // 所以实际上这里并不会发生交叉

    setbuf(stdout, NULL);   /* stdout is unbuffered */

    if (Fork() == 0)        /* child */

    {

        for (i = 0; i < nloop; i++)

        {

            Sem_wait(mutex);

            printf("child: %d\n", count++);

            Sem_post(mutex);

        }

        exit(0);

    }

    /* 4parent */

    for (i = 0; i < nloop; i++)

    {

        Sem_wait(mutex);

        printf("parent: %d\n", count++);

        Sem_post(mutex);

    }

    exit(0);

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

#include    "unpipc.h"

#define SEM_NAME    "mysem" // 有名信号量用于同步父子进程(加锁)

int main(int argc, char **argv)

{

    int     fd, i, nloop, zero = 0;

    int     *ptr; // 访问共享内存的指针

    sem_t   *mutex;

    if (argc != 3)

        err_quit("usage: incr2 <pathname> <#loops>");

    nloop = atoi(argv[2]);

    /* 4open file, initialize to 0, map into memory */

    fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE);

    Write(fd, &zero, sizeof(int)); // 向文件中写入一个int型的0

    // ptr返回共享内存起始位置

    ptr = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); // 映射一个int型大小的共享内存

    Close(fd);

    /* 4create, initialize, and unlink semaphore */

    mutex = Sem_open(Px_ipc_name(SEM_NAME), O_CREAT | O_EXCL, FILE_MODE, 1); // 信号量

    Sem_unlink(Px_ipc_name(SEM_NAME));

    setbuf(stdout, NULL);   /* stdout is unbuffered */

    if (Fork() == 0)        /* child */

    {

        for (i = 0; i < nloop; i++)

        {

            Sem_wait(mutex);

            printf("child: %d\n", (*ptr)++);

            Sem_post(mutex);

        }

        exit(0);

    }

    /* 4parent */

    for (i = 0; i < nloop; i++)

    {

        Sem_wait(mutex);

        printf("parent: %d\n", (*ptr)++);

        Sem_post(mutex);

    }

    exit(0);

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

[[email protected] shm]$ ./incr2 ./count.data 100

parent: 0

parent: 1

parent: 2

parent: 3

....

child: 197

child: 198

child: 199

[[email protected] shm]$ ll count.data

-rw-r--r--. 1 dell dell 4 8月  18 14:28 count.data

[[email protected] shm]$ file count.data

count.data: data

[[email protected] shm]$ hexdump -d count.data

0000000   00200   00000                                               

0000004

[[email protected] shm]$

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

#include    "unpipc.h"

struct shared

{

    sem_t mutex;      /* the mutex: a Posix memory-based semaphore */ // 匿名信号量

    int   count;      /* and the counter */

} shared;

int main(int argc, char **argv)

{

    int     fd, i, nloop;

    struct shared   *ptr;

    if (argc != 3)

        err_quit("usage: incr3 <pathname> <#loops>");

    nloop = atoi(argv[2]);

    /* 4open file, initialize to 0, map into memory */

    fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE);

    Write(fd, &shared, sizeof(struct shared));

    ptr = Mmap(NULL, sizeof(struct shared), PROT_READ | PROT_WRITE,

               MAP_SHARED, fd, 0);

    Close(fd);

    /* 4initialize semaphore that is shared between processes */

    Sem_init(&ptr->mutex, 1, 1); // 初始化匿名信号量，设置为进程共享，初始值为1

    setbuf(stdout, NULL);   /* stdout is unbuffered */

    if (Fork() == 0)        /* child */

    {

        for (i = 0; i < nloop; i++)

        {

            Sem_wait(&ptr->mutex);

            printf("child: %d\n", ptr->count++);

            Sem_post(&ptr->mutex);

        }

        exit(0);

    }

    /* 4parent */

    for (i = 0; i < nloop; i++)

    {

        Sem_wait(&ptr->mutex);

        printf("parent: %d\n", ptr->count++);

        Sem_post(&ptr->mutex);

    }

    exit(0);

}