同步与互斥之信号量

目录

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

验证

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

验证

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

代码一

代码二

验证

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

 验证

---

        信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被
用来控制对公共资源的访问。当信号量值大于 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)
{ // psem_wait(&sem1);my_printf((char *)arg);// vsem_post(&sem2);
}
void *syn_fun2(void *arg)
{ // psem_wait(&sem2);my_printf((char *)arg);// vsem_post(&sem3);
}
void *syn_fun3(void *arg)
{ // psem_wait(&sem3);my_printf((char *)arg);// vsem_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表示初始化值1sem_init(sem, 1, 1);pid_t pid = fork();if (pid == 0) // 子进程{// psem_wait(sem);my_printf("child process\n");// vsem_post(sem);}else if (pid > 0) // 父进程{// psem_wait(sem);my_printf("father process\n");// vsem_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表示初始化值1sem_init(sem1,1,1);sem_init(sem2,1,0);pid_t pid =fork();if(pid ==0)//子进程{//psem_wait(sem1);my_printf("this is  child process\n");//vsem_post(sem2);}else if(pid >0){//psem_wait(sem2);my_printf("this is father process\n");//vsem_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);// psem_wait(sem1);// 任务my_printf("this is sem1\n");// vsem_post(sem2);// 任务my_printf("this is sem2\n");//psem_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，保证了只有一个进程可以访问第一个任务的代码，实现了互斥

 验证