进程与线程的同步、互斥

最新推荐文章于 2024-08-22 13:51:37 发布
最新推荐文章于 2024-08-22 13:51:37 发布
阅读量56 收藏
点赞数
分类专栏： # IO 与 进程 文章标签： 算法 c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41566483/article/details/134245573
版权

————————————————————————

进程的同步、互斥

通过 信号灯集（semaphore）实现。

信号灯集 —— 实现同步

待完善。

信号灯集 —— 实现互斥

待完善。

💡练习：打印 AB

💡同步实现
// prog_syn.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define KEY 20230804

void print_char(char ch) {
    printf("%c ", ch);
    fflush(stdout);
}

// P操作，申请资源
void semaphore_p(int sem_id, int sem_num) {
    struct sembuf sem_buf = {sem_num, -1, 0};
    semop(sem_id, &sem_buf, 1);
}

// V操作，释放资源
void semaphore_v(int sem_id, int sem_num) {
    struct sembuf sem_buf = {sem_num, 1, 0};
    semop(sem_id, &sem_buf, 1);
}

int main(int argc, char const *argv[]) {
    // 创建信号量集
    int sem_id = semget(KEY, 2, IPC_CREAT | 0666);
    if (sem_id == -1) {
        perror("Failed to semget");
        return -1;
    }

    // 初始化信号量集
    union semun {
        int val;
        struct semid_ds *buf;
        ushort *array;
    } arg;

    arg.array = (ushort *)malloc(sizeof(ushort) * 2);
    arg.array[0] = 1;  // 初始化信号量0为1，表示A进程可以打印
    arg.array[1] = 0;  // 初始化信号量1为0，表示B进程等待

    if (semctl(sem_id, 0, SETALL, arg) == -1) {
        perror("Failed to semctl");
        return -1;
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("Failed to fork");
        return -1;
    } else if (pid == 0) {
        // 子进程，负责打印字符B
        while (1) {
            semaphore_p(sem_id, 1);  // 等待信号量1
            print_char('B');
            semaphore_v(sem_id, 0);  // 发送信号量0
        }
    } else {
        // 父进程，负责打印字符A
        while (1) {
            sleep(1);
            semaphore_p(sem_id, 0);  // 等待信号量0
            print_char('A');
            semaphore_v(sem_id, 1);  // 发送信号量1
        }
    }

    // 销毁信号量集
    if (semctl(sem_id, 0, IPC_RMID) == -1) {
        perror("Failed to semctl");
        return -1;
    }

    return 0;
}

运行结果如下：
在这里插入图片描述

💡互斥实现
// prog_mut.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <sys/wait.h>

// 定义信号灯集的键值
#define SEM_KEY 8041942

// 定义信号量操作结构体
struct sembuf sem_operation;

void print_char(char ch) {
    printf("%c ", ch);
    fflush(stdout);
}

// P操作，申请资源
void semaphore_p(int sem_id, int sem_num) {
    struct sembuf sem_buf = {sem_num, -1, 0};
    semop(sem_id, &sem_buf, 1);
}

// V操作，释放资源
void semaphore_v(int sem_id, int sem_num) {
    struct sembuf sem_buf = {sem_num, 1, 0};
    semop(sem_id, &sem_buf, 1);
}

int main(int argc, char const *argv[]) {

    // 创建信号灯集
    int sem_id = semget(SEM_KEY, 1, IPC_CREAT | 0666);
    if (sem_id == -1) {
        perror("Failed to create semaphore set");
        return 1;
    }

    // 初始化信号量集
    union semun {
        int val;
        struct semid_ds *buf;
        ushort *array;
    } arg;

    arg.array = (ushort *)malloc(sizeof(ushort) * 1);
    arg.array[0] = 1;  // 初始化信号量0为1，A\B进程抢夺资源

    // 初始化信号量为1，表示可用
    if (semctl(sem_id, 0, SETVAL, 1) == -1) {
        perror("Failed to initialize semaphore");
        return 1;
    }

    // 创建子进程
    pid_t pid = fork();
    if (pid == -1) {
        perror("Failed to fork");
        return 1;
    }

    if (pid == 0) {
        // 子进程
        for (int i = 0; i < 10; i++) {
            // sleep(1);               // 情况二：此句 sleep 被注释掉，下句 sleep 取消注释
            // 进入临界区前等待信号量可用
            semaphore_p(sem_id, 0);

            // 进入临界区，打印字母B
            print_char('B');

            // 释放信号量，表示临界区可用
            semaphore_v(sem_id, 0);
        }
    } else {
        // 父进程
        for (int i = 0; i < 10; i++) {
            // sleep(1);				// 情况一：此句 sleep 被注释掉，上句 sleep 取消注释
            // 进入临界区前等待信号量可用
            semaphore_p(sem_id, 0);

            // 进入临界区，打印字母A
            print_char('A');

            // 释放信号量，表示临界区可用
            semaphore_v(sem_id, 0);
        }
        wait(NULL);
    }

    putchar(10);

    // 删除信号灯集
    // if (semctl(sem_id, 0, IPC_RMID) == -1) {
    //     perror("Failed to remove semaphore set");
    //     return -1;
    // }
    
    return 0;
}

运行结果如下：
在这里插入图片描述

————————————————————————

线程的同步、互斥

通过 信号量 可以实现线程的同步和互斥；
通过 互斥锁 可以实现线程的互斥；
通过 互斥锁 + 条件变量 可以实现线程的同步。

信号量 —— 实现同步

sem_t sem1, sem2, …, sem_n;
sem_init(&sem1, 0, 1);
sem_init(&sem2, 0, 0);
…
sem_init(&sem_n, 0, 0);

*thread_1{
sem_wait(&sem1);
// 临界区
sem_post(&sem2);
}
*thread_2{
sem_wait(&sem2);
// 临界区
sem_post(&sem3);
}
…
*thread_n{
sem_wait(&sem_n);
// 临界区
sem_post(&sem_1);
}

信号量 —— 实现互斥

sem_t sem;
sem_init(&sem, 0, 1);
*thread_1{
sem_wait(&sem);
// 临界区
sem_post(&sem);
}
*thread_2{
sem_wait(&sem);
// 临界区
sem_post(&sem);
}
…
*thread_n{
sem_wait(&sem);
// 临界区
sem_post(&sem);
}

💡练习：字符串正序、倒序输出

💡同步实现
// sem_syn.c

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

char buf[64] = "";
sem_t sem1, sem2;

void *reverse(void *arg){
    while (1){
        char *p = buf;
        char *head = p;
        char *tail = NULL;
        while (*(p+1) != '\0')
            p++;
        tail = p;

        sem_wait(&sem1);
        while (head < tail){
            *head ^= *tail;
            *tail ^= *head;
            *head++ ^= *tail--;
        }
        sem_post(&sem2);
    }
    pthread_exit(0);
}

void *output(void *arg){

    while (1){
        sleep(1);							// 只加在一个线程函数内即可
        sem_wait(&sem2);
        printf("%s\n", buf);
        sem_post(&sem1);
    }
    
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
    sem_init(&sem1, 0, 1);
    sem_init(&sem2, 0, 0);

    strcpy(buf, "Welcome to my world!");

    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, output, NULL) != 0){
        perror("Failed to create a thread");
        return -1;
    }
    if (pthread_create(&tid2, NULL, reverse, NULL) != 0){
        perror("Failed to create a thread");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

运行结果如下：
在这里插入图片描述

💡互斥实现（无规律）
// sem_mut.c

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

char buf[64] = "";
sem_t sem;

void *reverse(void *arg){
    while (1){
        char *p = buf;
        char *head = p;
        char *tail = NULL;
        while (*(p+1) != '\0')
            p++;
        tail = p;

        sem_wait(&sem);
        while (head < tail){
            *head ^= *tail;
            *tail ^= *head;
            *head++ ^= *tail--;
        }
        sem_post(&sem);
    }
    pthread_exit(0);
}

void *output(void *arg){

    while (1){
        sleep(1);									// 只加在一个线程函数内即可
        sem_wait(&sem);
        printf("%s\n", buf);
        sem_post(&sem);
    }
    
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
    sem_init(&sem, 0, 1);

    strcpy(buf, "Welcome to my world!");

    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, output, NULL) != 0){
        perror("Failed to create a thread");
        return -1;
    }
    if (pthread_create(&tid2, NULL, reverse, NULL) != 0){
        perror("Failed to create a thread");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

运行结果如下：
在这里插入图片描述

— — — — — — — — — — — — — — — — — — — — — — — — — — —

互斥锁 —— 实现互斥

pthread_mutex_t lock;

*thread_1{
pthread_mutex_lock(&lock);
// 临界区
pthread_mutex_unlock(&lock);
}
*thread_2{
pthread_mutex_lock(&lock);
// 临界区
pthread_mutex_unlock(&lock);
}
…
*thread_n{
pthread_mutex_lock(&lock);
// 临界区
pthread_mutex_unlock(&lock);
}

互斥锁 + 条件变量 —— 实现同步

双线程：可以先让其中一个线程 sleep，以确保另一个线程先抢到时间片。
多线程：定义 flag = 0; 在每个线程中修改 flag 的值。pthread_cond_broadcast(&condition);

pthread_mutex_t lock;
pthread_cond_t condition;
int flag = 0;

*thread_1{
pthread_mutex_lock(&lock);
while(flag != 0)
pthread_cond_wait(&condition, &lock);
// 临界区
flag = 1;
pthread_cond_broadcast(&condition);
pthread_mutex_unlock(&lock);
}
*thread_2{
pthread_mutex_lock(&lock);
while(flag != 1)
pthread_cond_wait(&condition, &lock);
// 临界区
flag = 2;
pthread_cond_broadcast(&condition);
pthread_mutex_unlock(&lock);
}
…
*thread_n{
pthread_mutex_lock(&lock);
while(flag != n-1)
pthread_cond_wait(&condition, &lock);
// 临界区
flag = n;
pthread_cond_broadcast(&condition);
pthread_mutex_unlock(&lock);
}

💡练习：打印 ABC

💡互斥实现（乱序）：
// mutex_mut.c

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

pthread_mutex_t lock;

void *print1(void *arg){

    for (int i = 1; i <= 6; i++){

        pthread_mutex_lock(&lock);
        printf("%d: A\t", i);
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

void *print2(void *arg){

    for (int i = 1; i <= 6; i++){
        sleep(1);
        pthread_mutex_lock(&lock);
        printf("%d: B\t", i);
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

void *print3(void *arg){

    for (int i = 1; i <= 6; i++){
        sleep(2);
        pthread_mutex_lock(&lock);
        printf("%d: C\t", i);
        putchar(10); 
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2, tid3;
    if (pthread_create(&tid1, NULL, print1, NULL)){
        perror("Failed: ");
        return -1;
    }
    if (pthread_create(&tid2, NULL, print2, NULL)){
        perror("Failed: ");
        return -1;
    }
    if (pthread_create(&tid3, NULL, print3, NULL)){
        perror("Failed: ");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_mutex_destroy(&lock);

    return 0;
}

运行结果如下：
在这里插入图片描述

💡同步实现：
// mutex_syn.c

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

pthread_mutex_t lock;
pthread_cond_t condition;
int flag = 0;

void *print1(void *arg){

    for (int i = 1; ; i++){

        pthread_mutex_lock(&lock);
        while(flag != 0)
            pthread_cond_wait(&condition, &lock);

        printf("%d: A\t", i);

        flag = 1;
        pthread_cond_broadcast(&condition);
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

void *print2(void *arg){

    for (int i = 1; ; i++){

        pthread_mutex_lock(&lock);
        while(flag != 1)
            pthread_cond_wait(&condition, &lock);

        printf("%d: B\t", i);

        flag = 2;
        pthread_cond_broadcast(&condition);
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

void *print3(void *arg){

    for (int i = 1; ; i++){
        sleep(1);									// 只加在一个线程函数内即可
        
        pthread_mutex_lock(&lock);
        while(flag != 2)
            pthread_cond_wait(&condition, &lock);

        printf("%d: C\t", i);
        putchar(10); 

        flag = 0;
        pthread_cond_broadcast(&condition);
        pthread_mutex_unlock(&lock);
    }
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2, tid3;
    if (pthread_create(&tid1, NULL, print1, NULL)){
        perror("Failed: ");
        return -1;
    }
    if (pthread_create(&tid2, NULL, print2, NULL)){
        perror("Failed: ");
        return -1;
    }
    if (pthread_create(&tid3, NULL, print3, NULL)){
        perror("Failed: ");
        return -1;
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&condition);

    return 0;
}

运行结果如下：
在这里插入图片描述

————————————————————————

_小白__
关注
专栏目录
【操作系统】进程同步与互斥及其实现方式
qq_45596525的博客
03-22 2357
1. 什么是进程同步 进程具有异步性的特征, 各个并发执行的进程以独立的不可预知的速度推进 进程同步机制是为了解决进程异步的问题, 也被称为直接制约关系 2. 什么是进程互斥 OS中的某些资源虽然可以提供给多个进程使用,但一个时间段内只允许有一个进程访问该资源(这种资源被称为临界资源) do{ 进入区 // 检查是否可进入临界区, 若可进入则**对资源上锁** 临界区 // 访问临界资源的代码, 也叫临界段 退出区 // **对资源解锁** 剩余区 // 做其它处理 } 临界资源的互斥访问
线程的同步与互斥
q496958148的博客
05-08 246
线程同步与互斥：我们先来一个示例看一下：#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <string.h> #include <unistd.h> #include <sys/syscall.h>int i = 10;void* fun(void* arg) { char* id = (char
编程实现进程（线程）同步和互斥
11-25
在Windows等操作系统下，使用的VC、VB、java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。
详解线程同步和线程互斥，Java如何实现线程同步和互斥
做兴趣使然的Hero
06-09 1122
最开始我们的操作系统的作业的调度单位是进程，但是由于每个进程都单独占据一个资源，而且进程的形态转换非常的耗费系统资源。为了系统的调度更加轻量级，能够更好的支持并发，因此引入了线程这个概念。...
同步与互斥（进程、线程）
最新发布
2301_76226118的博客
08-22 997
同步：是指散步在不同任务之间的若干程序片段，它们的运行必须严格按照规定的某种先后 次序来运行，这种先后次序依赖于要完成的特定的任务，最基本的场景就是任务之间 的依赖，比如A任务的运行依赖于B任务产生的数据。
c++并发编程之线程的互斥与同步
weixin_30517001的博客
06-11 151
什么是线程的同步与互斥？ 互斥：指在某一时刻指允许一个进程运行其中的程序片，具有排他性和唯一性。对于线程A和线程B来讲，在同一时刻，只允许一个线程对临界资源进行操作，即当A进入临界区对资源操作时，B就必须等待；当A执行完，退出临界区后，B才能对临界资源进行操作。 同步：指的是在互斥的基础上，实现进程之间的有序访问。假设现有线程A和线程B，线程A需要往缓冲区写数据，线程B需要从缓冲区读数据...
进程(线程)的同步与互斥
Irving___的博客
12-09 3365
目录一、实验题目二、实验目的三、实验内容与要求四、算法描述（含数据结构定义）或流程图五、实验过程六、实验结果分析 一、实验题目 进程(线程)的同步与互斥 二、实验目的 1． 掌握基本的同步与互斥算法，理解生产者消费者模型。 2． 学习使用Windows中基本的同步对象，掌握相关API的使用方法。 3． 了解Windows中多线程的并发执行机制，实现进程的同步与互斥。 三、实验内容与要求 1． 实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟
进程的同步与互斥习题(含部分题目的参考答案).doc
01-03
进程的同步与互斥习题 本文将对进程的同步与互斥习题进行详细的解释和分析，涵盖了多种不同的场景和问题，包括进程的同步、互斥、信号量、缓冲区、生产者消费者问题、读者写者问题、司机与售票员问题、汽车过桥问题...
操作系统实验报告_进程同步与互斥.doc
07-13
实验中，设计了一个控制台进程，在该进程中创建 n 个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 实验环境：Windows 2000/XP + Visual C++ 6.0 实验容：以生产者-消费者模型为依据，在 Windows 2000/XP...
Linux系统编程（六）线程同步、互斥机制
qq_1033275663的博客
05-31 1004
在 Posix Thread 中定义了一套专门用于线程互斥的 mutex 函数。mutex 是一种简单的加锁的方法来控制对共享资源的存取。这个互斥锁只有两种状态（上锁和解锁）。问题：为什么需要对共享资源加锁？答：因为多个线程共用进程的资源，要访问的是公共区间时（全局变量），当一个线程访问的时候，需要加上锁以防止另外的线程对它进行访问，以实现资源的独占。在一个时刻只能有一个线程掌握某个互斥锁，拥有上锁状态的线程才能够对共享资源进行操作。
线程间的同步和互斥
weixin_51547017的博客
10-24 1085
1.进程是资源分配的最小单位，线程是CPU调度的最小单位，即程序执行的最小单位；2.每个进程都有自己独立的地址空间，同一个进程的多个线程共用一个地址空间；3.线程的上下文切换比进程要快；
线程/进程 的互斥和同步机制
程序客栈
02-11 3389
在我的Linux专栏中 讲到过多进程编程和多线程编程 二者的定义和用法我都做了详细的讲解,并且还附带了源代码 在期间有个重要的概念我们需要单独拎出来讲 我们知道, 多个进程/线程同时访问同一共享资源时 会造成数据混乱 因此呢,才需要互斥和同步机制进行保护 互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是...
学习笔记☞python3☞网络编程（七） ☞【进程间通信(二)，同步和互斥，线程，线程通信，线程同步互斥方法（一）】
赵卫坡的博客
05-17 263
1、进程间通信(二)    1、信号处理        signal.signal(signum,handler)            功能：                处理一个信号            参数：                signum ：  要处理的信号                handler：  对该信号的处理方法                        ...
进程/线程的互斥与同步
weixin_42579072的博客
06-19 545
一、进程互斥和同步的实现
线程互斥和同步的实现方法
qq_44194231的博客
05-05 1006
1.同步：线程函数之间运行时存在先后关系，则成为同步 解决办法：信号量 信号量也是一个变量，需要初始化 1.　sem_init 函数形式：int sem_init(sem_t *sem, int pshared, unsigned int value)。 功能：初始化信号量值。 参数：sem为信号量变量指针；pshared指定信号量是由进程内线程共享，还是由进程之间共享，若为了0则是线程共享，...
进程的同步与互斥
编程小白养成手记
04-09 799
回顾 进程具有异步性，异步性是指，各个并发执行的进程以各自独立的、不可预知的速度向前推进。 进程的同步 同步也称直接制约关系，他是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调他们的工作次序而产生的制约关系。进程间的制约关系就是源于他们之间的相互合作。 例如：之前讲到的管道通信，写进程将所有的数据写入到管道，写完后，读进程才能读取；在写数据和读数据两个操作执行的先后顺序是...
线程同步互斥机制
hblhly的专栏
06-20 764
线程同步互斥机制4种最基本方法实现——临界区（关键段 critical section）、互斥量（mutex）、信号量（semaphore）、事件（event）。1、线程（进程）同步的主要任务在引入多线程后，由于线程执行的异步性，会给系统造成混乱，特别是在急用临界资源时，如多个线程急用同一台打印机，会使打印结果交织在一起，难于区分。当多个线程急用共享变量，表格，链表时，可能会导致数据处理出错，因此...
进程/线程同步互斥的四种基础控制方法详解
本文主要介绍了四种基本的进程或线程同步互斥控制方法：临界区、互斥量、信号量和事件。这些方法是现代操作系统中实现线程并发控制的核心技术，它们在.Net和Java等编程语言的线程管理中起到关键作用。 1. **临界区*...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值