信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被
用来控制对公共资源的访问。当信号量值大于 0 时，则可以访问，否则将阻塞。信号量是一种用于控制进程或线程同步和互斥的机制。它通常由一个计数器和一组等待的进程或线程组成。当进程或线程需要访问共享资源时，它会尝试获取一个信号量。如果信号量的计数器大于0，则进程或线程可以获得信号量并继续执行。否则，进程或线程将被阻塞，直到有信号量可用。

PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。

信号量数据类型为：sem_t

1、信号量用于线程的互斥

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

// 定义一个信号量(用于互斥)
sem_t sem;

void my_printf(char *str)
{
    int i = 0;
    while (str[i] != '\0')
    {
        printf("%c", str[i++]);
        fflush(stdout);
        sleep(1);
    }
}
void *fun1(void *arg)
{
    // P 操作
    sem_wait(&sem);
    my_printf((char *)arg);
    // V 操作
    sem_post(&sem);
}
void *fun2(void *arg)
{
    // P 操作
    sem_wait(&sem);
    my_printf((char *)arg);
    // V 操作
    sem_post(&sem);
}
void *fun3(void *arg)
{
    // P 操作
    sem_wait(&sem);
    my_printf((char *)arg);
    // V 操作
    sem_post(&sem);
}
int main(int argc, char *argv[])
{
    // 信号量初始化为1 第二个参数0表示用于线程,第三个信号量初始值
    sem_init(&sem, 0, 1);
    pthread_t tid1, tid2, tid3;

    pthread_create(&tid1, NULL, fun1, "this is tid1\n");
    pthread_create(&tid2, NULL, fun2, "this is tid2\n");
    pthread_create(&tid3, NULL, fun3, "this is tid3\n");

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);

    //销毁信号量
    sem_destroy(&sem);
    return 0;
}

实现了三个线程的并发输出，但是通过信号量sem保证了只有一个线程在输出时访问标准输出流，即实现了互斥。

定义了一个信号量 sem 用于实现互斥访问。三个线程 tid1、tid2 和 tid3 将同时运行，它们的目标是调用 my_printf 函数打印不同的字符串，但是这些线程之间需要互斥访问共享资源，否则会导致输出的字符串混乱。

在 fun1、fun2 和 fun3 函数中，首先调用 sem_wait 函数来申请信号量资源，表示进入临界区，如果信号量的值为1，则将其减1，表示申请成功，否则阻塞等待。然后调用 my_printf 函数输出相应的字符串，最后调用 sem_post 函数释放信号量资源，将其加1，表示退出临界区，其他线程就可以申请这个资源了。

主函数中，初始化了信号量，创建三个线程，分别调用 fun1、fun2 和 fun3 函数，最后等待三个线程执行结束，销毁信号量。

验证

线程的执行顺序是不确定的，由操作系统决定。虽然代码中是先创建tid1线程，但是操作系统可能会优先执行tid3线程，所以最终的执行结果可能是tid3先执行，然后是tid2，最后是tid1。因此，不能依赖代码中的线程创建顺序来确定线程的执行顺序。

2、信号量用于线程的同步

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

// 定义三个信号量(用于同步)
sem_t sem1, sem2, sem3;
void my_printf(char *str)
{
    int i = 0;
    while (str[i] != '\0')
    {
        printf("%c", str[i++]);
        fflush(stdout);
        sleep(1);
    }
}
void *syn_fun1(void *arg)
{ // p
    sem_wait(&sem1);
    my_printf((char *)arg);
    // v
    sem_post(&sem2);
}
void *syn_fun2(void *arg)
{ // p
    sem_wait(&sem2);
    my_printf((char *)arg);
    // v
    sem_post(&sem3);
}
void *syn_fun3(void *arg)
{ // p
    sem_wait(&sem3);
    my_printf((char *)arg);
    // v
    sem_post(&sem1);
}
int main(int argc, char *argv[])
{
    // 信号量初始化为1 第二个参数0表示用于线程
    sem_init(&sem1, 0, 1);
    sem_init(&sem2, 0, 0);
    sem_init(&sem3, 0, 0);

    pthread_t tid1, tid2, tid3;

    pthread_create(&tid1, NULL, syn_fun1, "this is tid1\n");
    pthread_create(&tid2, NULL, syn_fun2, "this is tid2\n");
    pthread_create(&tid3, NULL, syn_fun3, "this is tid3\n");

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    // 销毁信号量
    sem_destroy(&sem1);
    sem_destroy(&sem2);
    sem_destroy(&sem3);

    return 0;
}

实现了三个线程的同步执行，即按照指定的顺序依次输出三个字符串。其中，使用了三个信号量来实现同步，分别为sem1、sem2、sem3。这三个信号量的初始值分别为1、0、0，表示sem1可以被访问，而sem2和sem3需要等待其他线程的信号才能被访问。三个线程分别对应syn_fun1、syn_fun2、syn_fun3函数，每个函数中都使用了sem_wait和sem_post来对信号量进行操作。其中，sem_wait用于P操作，即尝试获取信号量，如果信号量的值为0，则线程会阻塞等待其他线程的信号；而sem_post用于V操作，即释放信号量，将信号量的值加1，表示其他线程可以访问这个信号量了。最后，在main函数中创建三个线程，并使用pthread_join等待线程结束，最后销毁信号量。

验证

虽然定义了三个信号量，但是初始值为1的信号量只有一个，所以，只有为1的信号量对应的sem1能运行，其他的需要等待信号，也就确保了只有tid1先运行，不会像上面互斥一样随机运行

3、无名信号量用于进程间互斥

无名信号量是一种特殊类型的信号量，它只能被同一进程内的线程使用。它们不需要被命名，因此被称为“无名信号量”。无名信号量通常用于控制线程之间的同步和互斥。在代码示例中，sem_init 函数用于初始化一个无名信号量，而 sem_wait 和 sem_post 函数分别用于等待和释放信号量。

代码一

#include <stdio.h>
#include <semaphore.h>
#include <unistd.h>
#include <sys/mman.h>


void my_printf(char *str)
{
    int i = 0;
    while (str[i] != '\0')
        printf("%c", str[i++]);
    fflush(stdout);
    sleep(1);
}
int main(int argc, char *argv[])
{
    // 定义一个无名信号量
    // MAP_ANONYMOUS匿名映射 ‐1不需要文件描述符
    sem_t *sem = mmap(NULL,
                      sizeof(sem_t),
                      PROT_READ |
                      PROT_WRITE,
                      MAP_SHARED |
                      MAP_ANONYMOUS,
                      -1, 0);
    // 无名信号量的初始化 第一个1表示进程 第二个1表示初始化值1
    sem_init(sem, 1, 1);
    pid_t pid = fork();
    if (pid == 0) // 子进程
    {
        // p
        sem_wait(sem);
        my_printf("child process\n");
        // v
        sem_post(sem);
    }
    else if (pid > 0) // 父进程
    {
        // p
        sem_wait(sem);
        my_printf("father process\n");
        // v
        sem_post(sem);
    }
    sem_destroy(sem);
    return 0;
}

通过调用mmap函数，将信号量映射到进程的虚拟内存空间中。然后，使用sem_init初始化信号量的值为1，表示当前没有其他进程在访问它。接着，通过调用fork函数创建一个子进程。在父进程中，调用sem_wait函数尝试获得对信号量的访问权。由于这是第一个进程，因此它能够获得对信号量的访问权。它打印一条消息，然后使用sem_post函数释放对信号量的访问权。在子进程中，它也会尝试获得对信号量的访问权，但是由于父进程已经获得了对信号量的访问权，所以子进程必须等待父进程释放对信号量的访问权。然后它打印一条消息，再次使用sem_post函数释放对信号量的访问权。最后，调用sem_destroy函数销毁信号量并释放资源。

mmap是一个系统调用，用于将一个文件或设备映射到内存中。在上面的代码中，它的作用是为共享内存分配一块内存区域，返回的是指向这个区域的指针。mmap函数的调用参数解释如下：

NULL：表示分配内存区域的起始地址，由系统自动分配
sizeof(sem_t)：表示需要分配的内存区域的大小
PROT_READ | PROT_WRITE：表示内存区域的访问权限，这里是可读可写
MAP_SHARED：表示这块内存区域是被多个进程共享的,使用了 MAP_ANONYMOUS 标志来创建一个匿名映射，一个无名的共享内存区域,不需要与文件关联
fd：表示文件描述符，这里是共享内存的文件描述符,‐1不需要文件描述符
0：表示偏移量，这里没有偏移，从文件开头开始映射
成功返回映射区的首地址

代码二

#include <stdio.h>
#include <semaphore.h>
#include <unistd.h>
#include <sys/mman.h>


void  my_printf(char *str)
{
    int i=0;
    while(str[i] != '\0')
    {
        printf("%c", str[i++]);
        fflush(stdout);
        sleep(1);
    }
}
int main(int argc, char *argv[])
{
    //定义一个无名信号量
 //MAP_ANONYMOUS匿名映射 ‐1不需要文件描述符
    sem_t *sem1 = mmap(NULL, sizeof(sem_t),
                        PROT_READ|PROT_WRITE,
                        MAP_SHARED | MAP_ANONYMOUS,
                        -1,0);
    sem_t *sem2 = mmap(NULL, sizeof(sem_t),
                        PROT_READ|PROT_WRITE,
                        MAP_SHARED | MAP_ANONYMOUS,
                        -1,0);
    //无名信号量的初始化 第一个1表示进程 第二个1表示初始化值1
    sem_init(sem1,1,1);
    sem_init(sem2,1,0);

    pid_t pid =fork();
    if(pid ==0)//子进程
    {
        //p
        sem_wait(sem1);
        my_printf("this is  child process\n");
        //v
        sem_post(sem2);
    }
    else if(pid >0)
    {
        //p
        sem_wait(sem2);
        my_printf("this is father process\n");
        //v
        sem_post(sem1);
    }
    //销毁信号量
    sem_destroy(sem1);
    sem_destroy(sem2);
    return 0;

}

这段代码定义了两个无名信号量sem1和sem2，并使用mmap将它们分别映射到了进程的虚拟内存空间中。然后使用这两个无名信号量实现了进程间的同步。不同于前面那段代码，这段代码使用了两个不同的指针变量sem1和sem2分别指向映射到内存中的两个无名信号量。同时在创建子进程时，子进程通过sem2来等待父进程打开它，父进程通过sem1来等待子进程打开它。这样就实现了进程间的同步。总的来说，这两段代码使用的都是无名信号量来实现进程间同步，只不过一个使用了一个无名信号量，另一个使用了两个无名信号量来实现。

验证

两段代码结果打印的都是相同的信息

4、有名信号量用于进程间同步和互斥

#include <stdio.h>
#include <semaphore.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
void my_printf(char *str)
{
   int i = 0;
   while (str[i] != '\0')
   {
      printf("%c", str[i++]);
      fflush(stdout);
      sleep(1);
   }
}

int main(int argc, char **argv)
{
   // 创建2个有名信号量sem_open 最后一个参数为初始值
   sem_t *sem1 = sem_open("sem1", O_RDWR | O_CREAT, 0666, 1);
   sem_t *sem2 = sem_open("sem2", O_RDWR | O_CREAT, 0666,0);
   // p
   sem_wait(sem1);
   // 任务
   my_printf("this is sem1\n");
   // v
   sem_post(sem2);
   // 任务
   my_printf("this is sem2\n");
   //p
   sem_post(sem1);
   // 关闭信号量
   sem_close(sem1);
   sem_close(sem2);
   // 销毁信号量
   sem_destroy(sem1);
   sem_destroy(sem2);
   return 0;
}

进程通过sem_wait(sem1)获取sem1信号量，如果此时sem1的值为1，则将其减1，表示占用资源，否则阻塞等待。进程输出"this is sem1\n"，此时其他进程无法获得sem1信号量，从而实现了互斥。进程通过sem_post(sem2)释放sem2信号量，将其值加1，唤醒其他阻塞在sem2上的进程，从而实现了同步。此时其他进程可以获取sem2信号量，进行下一步操作。进程输出"this is sem2\n"，其他进程无法获取sem2信号量，从而实现了互斥。

在第二个任务执行完毕之后，调用sem_post(sem1)将sem1的值加一，此时又可以重新进入第一个任务。这种方式可以保证第一个任务和第二个任务的执行顺序，并且在第二个任务执行完毕之前第一个任务不会被重新执行。同时，由于sem1的初始值为1，保证了只有一个进程可以访问第一个任务的代码，实现了互斥

同步与互斥之信号量

1、信号量用于线程的互斥

验证

2、信号量用于线程的同步

验证

3、无名信号量用于进程间互斥

代码一

代码二

验证

4、有名信号量用于进程间同步和互斥

验证

猜你喜欢

同步与互斥之信号量

1、信号量用于线程的互斥

验证

2、信号量用于线程的同步

验证

3、无名信号量用于进程间互斥

代码一

代码二

验证

4、有名信号量 用于进程间同步和互斥

验证

猜你喜欢

4、有名信号量用于进程间同步和互斥