Linux下进程同步问题小例

原创 2017年01月03日 10:15:11

以下代码利用mmap给内存文件分配空间,利用fork产生父子进程,通过semaphore中的信号量进行同步和死锁操作。完成了父子进程的同步运行。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <sys/mman.h>
int* count = 0;
sem_t *mutex1 = NULL;
sem_t *mutex2 = NULL;
int finish = 0;
int main()
{
    mutex1 = (sem_t*)mmap(NULL, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
    mutex2 = (sem_t*)mmap(NULL, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
    count = (int*)mmap(NULL,sizeof(int), PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1,0);
    sem_init(mutex1, 1, 1);
    sem_init(mutex2, 1, 0);
    *count = 0;
    if(fork()==0)
    {
        while(1)
        {
            printf("child continue!\n");
            sem_wait(mutex1);
            *count += 2;
            printf("child:%d\n",*count);
            finish++;
            sem_post(mutex2);
            if(finish == 10)
                break;
        }
        printf("child Finish!\n");
        exit(0);
    }

    while(1)
    {
        printf("father continue!\n");
        sem_wait(mutex2);
        *count -= 1;
        printf("father:%d\n",*count);
        finish++;
        sem_post(mutex1);
        if(finish == 10)
            break;
    }
    sem_destroy(mutex1);
    sem_destroy(mutex2);
    munmap(mutex1, sizeof(sem_t));
    munmap(mutex2, sizeof(sem_t));
    munmap(count, sizeof(int));
    printf("Finished All!\n");
    return 0;
}

在linux下进行编译

[root@localhost myfile]# gcc testsem.c  -o testsem -lpthread

运行结果:

[root@localhost myfile]# ./testsem 
father continue!
child continue!
child:2
child continue!
father:1
father continue!
child:3
child continue!
father:2
father continue!
child:4
child continue!
father:3
father continue!
child:5
child continue!
father:4
father continue!
child:6
child continue!
father:5
father continue!
child:7
child continue!
father:6
father continue!
child:8
child continue!
father:7
father continue!
child:9
child continue!
father:8
father continue!
child:10
child continue!
father:9
father continue!
child:11
child Finish!
father:10
Finished All!
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Linux下信号量实现进程同步、互斥(生产者消费者问题)

linux的进程同步互斥实现生产者和消费者

Linux下的进程同步机制 – 记录锁

当可能出现几个进程争用(读、写)同一个Critical Section的时候,加锁是常用的做法。 Linux加锁的方法,除了经典的IPC(Semophore)之外,记录锁(Record Lockin...

进程同步之信号量机制(pv操作及经典问题)

1.信号量机制 信号量机制即利用pv操作来对信号量进行处理。 什么是信号量?信号量(semaphore)的数据结构为一个值和一个指针,指针指向等待该信号量的下一个进程。信号量的...

操作系统(经典进程同步问题)之写者优先

一个数据文件或记录可以被多个进程共享使用,我们将读文件的进程称为reader,写文件的进程成为writer。允许对个进程同属进行读取一个共享对象,因此读操作不会造成数据数据文件的混乱,但不允许read...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)