互斥锁，条件变量，读写锁，信号灯，共享内存的一些代码

最新推荐文章于 2024-07-09 09:44:36 发布
转载 最新推荐文章于 2024-07-09 09:44:36 发布 · 321 阅读 · 0

本文详细阐述了并发编程中的互斥锁、条件变量、读写锁和信号灯的实现，包括多生产者多消费者场景下的同步问题解决，并通过实例展示了如何在不同并发环境下进行资源管理和任务调度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//2010-01-19 yaojianming 摘自unix网络编程2卷

//以下为多生产者，单消费者的互斥锁，条件变量的实现

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

#define MAXNITEMS 100000
#define MAXNTHREADS 10

int nitems = MAXNITEMS;
int buff[MAXNITEMS];

struct val {
    pthread_mutex_t mutex;
    int nput;
    int nval;
} put = {
    PTHREAD_MUTEX_INITIALIZER, 0, 0
};

struct mutex_cond {
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int nready;
} nready = {
    PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0
};

void* produce(void* arg)
{
    while(1) {
        pthread_mutex_lock(&put.mutex);
        if (put.nput >= nitems) {
            pthread_mutex_unlock(&put.mutex);
            return NULL;
        }
        buff[put.nput] = put.nval;
        put.nput++;
        put.nval++;
        pthread_mutex_unlock(&put.mutex);

        int dosignal;
        pthread_mutex_lock(&nready.mutex);
        dosignal = (nready.nready == 0);
        nready.nready++;
        pthread_mutex_unlock(&nready.mutex);

        if (dosignal)
            pthread_cond_signal(&nready.cond);

        *((int*)arg) += 1;
    }
}

void* consume(void* arg)
{
    for(int i=0; i<nitems; ++i) {
        pthread_mutex_lock(&nready.mutex);
        while(nready.nready == 0)
            pthread_cond_wait(&nready.cond, &nready.mutex);
        nready.nready--;
        pthread_mutex_unlock(&nready.mutex);

        if(buff[i] != i)
            printf("buff[%d] = %d\n", i, buff[i]);
    }
}

int main()
{
    int nthreads = MAXNTHREADS;
    int count[MAXNTHREADS];
    pthread_t tid_produce[MAXNTHREADS];
    pthread_t tid_consume;

    for(int i=0; i<nthreads; ++i) {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }
    pthread_create(&tid_consume, NULL, consume, NULL);

    for(int i=0; i<nthreads; ++i) {
        pthread_join(tid_produce[i], NULL);
        printf("count[%d] = %d\n", i, count[i]);
    }
    printf("produce success\n");
    pthread_join(tid_consume, NULL);
    printf("consume success\n");

    return 0;
}


//2010-01-21 yaojianming 摘自unix网络编程2卷

//多个读者和多个写者的进程间通讯，采用读写锁

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

#define READERS 100
#define WRITERS 10

struct val {
    pthread_rwlock_t rwlock;
    int nval;
} put = {
    PTHREAD_RWLOCK_INITIALIZER, 0
};

void* thread_read(void* arg)
{
    int n = (*(int*)arg);
    pthread_rwlock_rdlock(&put.rwlock);
    printf("%d:---%d\n", n, put.nval); 
    pthread_rwlock_unlock(&put.rwlock);
} 

void* thread_write(void* arg)
{
    int n = (*(int*)arg);
    pthread_rwlock_wrlock(&put.rwlock);
    put.nval++;
    pthread_rwlock_unlock(&put.rwlock);
} 

int main()
{
    int count_read[READERS];
    int count_write[WRITERS];
    pthread_t tid_read[READERS];
    pthread_t tid_write[WRITERS];

    for(int i=0; i<READERS; ++i) {
        count_read[i] = i;
        pthread_create(&tid_read[i], NULL, thread_read, &count_read[i]);
    }
    for(int i=0; i<WRITERS; ++i) {
        count_write[i] = i;
        pthread_create(&tid_write[i], NULL, thread_write, &count_write[i]);
    }

    for(int i=0; i<READERS; ++i) {
        pthread_join(tid_read[i], NULL);
    }
    for(int i=0; i<WRITERS; ++i) {
        pthread_join(tid_write[i], NULL);
    }

    return 0;
}


//2010-01-26 yaojianming 摘自unix网络编程2卷

//单生产者，单消费者的posix信号灯的实现

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

#define NBUFF 10
#define NITEMS 100

struct val {
    int buff[NBUFF];
    sem_t mutex,nempty,nstored;
} shared;

int nitems = NITEMS;

void* produce(void* arg)
{
    for(int i=0; i<nitems; ++i) {
        sem_wait(&shared.nempty);
        sem_wait(&shared.mutex);
        printf("producen\n");
        shared.buff[i%NBUFF] = i;
        sem_post(&shared.mutex);
        sem_post(&shared.nstored);
    }
}

void* consume(void* arg)
{
    for(int i=0; i<nitems; ++i) {
        sem_wait(&shared.nstored);
        sem_wait(&shared.mutex);
        printf("consume\n");
        if (shared.buff[i%NBUFF] != i) {
            printf("buff[%d] = %d\n", i, shared.buff[i%NBUFF]);
        }
        sem_post(&shared.mutex);
        sem_post(&shared.nempty);
    }
}

int main()
{
    pthread_t tid_produce;
    pthread_t tid_consume;

    sem_init(&shared.mutex, 0, 1);
    sem_init(&shared.nempty, 0, NBUFF);
    sem_init(&shared.nstored, 0, 0);

    pthread_create(&tid_produce, NULL, produce, NULL);
    pthread_create(&tid_consume, NULL, consume, NULL);

    pthread_join(tid_produce, NULL);
    pthread_join(tid_produce, NULL);

    sem_destroy(&shared.mutex);
    sem_destroy(&shared.nempty);
    sem_destroy(&shared.nstored);

    return 0;
}


//2010-01-26 yaojianming 摘自unix网络编程2卷

//多生产者，单消费者的posix信号灯的实现

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

#define NBUFF 10
#define NITEMS 10000
#define MAXTHREADS 5

struct val {
    int buff[NBUFF];
    sem_t mutex,nempty,nstored;
    int nput;
    int nval;
} shared;

int nitems = NITEMS;

void* produce(void* arg)
{
    while(1) {
        sem_wait(&shared.nempty);
        sem_wait(&shared.mutex);
        if (shared.nput >= nitems) {
            sem_post(&shared.mutex);
            sem_post(&shared.nempty);
            return NULL;
        }
        shared.buff[shared.nput % NBUFF] = shared.nval;
        ++shared.nput;
        ++shared.nval;
        sem_post(&shared.mutex);
        sem_post(&shared.nstored);
        *((int*)arg) += 1;
    }
}

void* consume(void* arg)
{
    for(int i=0; i<nitems; ++i) {
        sem_wait(&shared.nstored);
        sem_wait(&shared.mutex);
        if (shared.buff[i%NBUFF] != i)
            printf("buff[%d] = %d\n", i, shared.buff[i%NBUFF]);
        sem_post(&shared.mutex);
        sem_post(&shared.nempty);
    }
}

int main()
{
    int count[MAXTHREADS];
    pthread_t tid_produce[MAXTHREADS];
    pthread_t tid_consume;

    sem_init(&shared.mutex, 0, 1);
    sem_init(&shared.nempty, 0, NBUFF);
    sem_init(&shared.nstored, 0, 0);

    for(int i=0; i<MAXTHREADS; ++i) {
        count[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &count[i]);
    }
    pthread_create(&tid_consume, NULL, consume, NULL);

    for(int i=0; i<MAXTHREADS; ++i) {
        pthread_join(tid_produce[i], NULL);
        printf("produce[%d] = %d\n", i, count[i]);
    }
    pthread_join(tid_consume, NULL);

    sem_destroy(&shared.mutex);
    sem_destroy(&shared.nempty);
    sem_destroy(&shared.nstored);

    return 0;
}


//2010-01-26 yaojianming 摘自unix网络编程2卷

//多生产者，多消费者的posix信号灯的实现

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

#define NBUFF 10

int nitems = 10000;
int nproduce = 15;
int nconsume = 15;

struct val {
    int buff[NBUFF];
    int nput;
    int nputval;
    int nget;
    int ngetval;
    sem_t mutex, nempty, nstored;
} shared;


void* produce(void* arg)
{
    while(1) {
        sem_wait(&shared.nempty);
        sem_wait(&shared.mutex);
        if (shared.nput >= nitems) {
            sem_post(&shared.nstored);
            sem_post(&shared.mutex);
            sem_post(&shared.nempty);
            return NULL;
        }
        shared.buff[shared.nput % NBUFF] = shared.nputval;
        shared.nput++;
        shared.nputval++;
        sem_post(&shared.mutex);
        sem_post(&shared.nstored);
        *((int*)arg) += 1;
    }
}

void* consume(void* arg)
{
    while(1) {
        sem_wait(&shared.nstored);
        sem_wait(&shared.mutex);
        if (shared.nget >= nitems) {
            sem_post(&shared.mutex);
            sem_post(&shared.nstored);
            return NULL;
        }
        int i = shared.nget % NBUFF;
        if (shared.buff[i] != shared.ngetval)
            printf("error buff[%d] = %d\n", i, shared.buff[i]);
        shared.nget++;
        shared.ngetval++;
        sem_post(&shared.mutex);
        sem_post(&shared.nempty);
        *((int*)arg) += 1;
    }
}

int main()
{
    int prodcount[30], conscount[30];
    pthread_t tid_produce[30], tid_consume[30];

    sem_init(&shared.mutex, 0, 1);
    sem_init(&shared.nempty, 0, NBUFF);
    sem_init(&shared.nstored, 0, 0);

    for(int i=0; i<nproduce; ++i) {
        prodcount[i] = 0;
        pthread_create(&tid_produce[i], NULL, produce, &prodcount[i]);
    }
    for(int i=0; i<nconsume; ++i) {
        conscount[i] = 0;
        pthread_create(&tid_consume[i], NULL, consume, &conscount[i]);
    }
    for(int i=0; i<nproduce; ++i) {
        pthread_join(tid_produce[i], NULL);
        printf("producer count[%d] = %d\n", i, prodcount[i]);
    }
    for(int i=0; i<nconsume; ++i) {
        pthread_join(tid_consume[i], NULL);
        printf("consume count[%d] = %d\n", i, conscount[i]);
    }

    sem_destroy(&shared.mutex);
    sem_destroy(&shared.nempty);
    sem_destroy(&shared.nstored);

    return 0;
}


//http://blog.youkuaiyun.com/KataDoc360/archive/2008/11/21/3348023.aspx

//进程间共享内存和信号灯同时使用


//share.h

#define sem_key 2010
#define shm_key 2011
#define SEM_PERM 0600
#define SHM_PERM 0600

struct content {
        int nput;
        int nval;
};

//client.cpp

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

#include "share.h"

void lock_sem()
{
        struct sembuf ops[2];
        ops[0].sem_num = 0;
        ops[0].sem_op = 0;
        ops[0].sem_flg = 0;
        ops[1].sem_num = 0;
        ops[1].sem_op = 1;
        ops[1].sem_flg = SEM_UNDO;

        int nsemid = semget(sem_key, 1, SEM_PERM|IPC_CREAT);
        if (nsemid < 0) {
                perror("semget");
        }
        int nret = semop(nsemid, &ops[0], 2);
        if (nret < 0) {
                perror("semop");
        }
}

void unlock_sem()
{
        struct sembuf ops[1];
        ops[0].sem_num = 0;
        ops[0].sem_op = -1;
        ops[0].sem_flg = SEM_UNDO|IPC_NOWAIT;

        int nsemid = semget(sem_key, 1, SEM_PERM|IPC_CREAT);
        if (nsemid < 0) {
                perror("semget");
        }
        int nret = semop(nsemid, &ops[0], 1);
        if (nret < 0) {
                perror("semop");
        }
}

int main()
{
        int nshmid = shmget(shm_key, sizeof(content), SHM_PERM|IPC_CREAT);
        if (nshmid < 0) {
                perror("shmget");
        }

        struct content* p = (content*)shmat(nshmid, NULL, 0);
        lock_sem();
        p->nput++;
        p->nval++;
        unlock_sem();

        return 0;
}

//server.cpp

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

#include "share.h"

void lock_sem()
{
        struct sembuf ops[2];
        ops[0].sem_num = 0;
        ops[0].sem_op = 0;
        ops[0].sem_flg = 0;
        ops[1].sem_num = 0;
        ops[1].sem_op = 1;
        ops[1].sem_flg = SEM_UNDO;

        int nsemid = semget(sem_key, 1, SEM_PERM|IPC_CREAT);
        if (nsemid < 0) {
                perror("semget");
        }
        int nret = semop(nsemid, &ops[0], 2);
        if (nret < 0) {
                perror("semop");
        }
}

void unlock_sem()
{
        struct sembuf ops[1];
        ops[0].sem_num = 0;
        ops[0].sem_op = -1;
        ops[0].sem_flg = SEM_UNDO|IPC_NOWAIT;

        int nsemid = semget(sem_key, 1, SEM_PERM|IPC_CREAT);
        if (nsemid < 0) {
                perror("semget");
        }
        int nret = semop(nsemid, &ops[0], 1);
        if (nret < 0) {
                perror("semop");
        }
}

void delete_sem()
{
        int nsemid = semget(sem_key, 1, SEM_PERM|IPC_CREAT);
        if (nsemid < 0) {
                perror("semget");
        }

        semctl(nsemid, 0, IPC_RMID);
}

int main()
{
        int nshmid = shmget(shm_key, sizeof(content), SHM_PERM|IPC_CREAT);
        if (nshmid < 0) {
                perror("shmget");
        }

        struct content *p = (content*)shmat(nshmid, NULL, 0);
        lock_sem();
        printf("nput:%d = %d\n", p->nput, p->nval);
        unlock_sem();

        shmctl(nshmid, IPC_RMID, 0);
        delete_sem();

        return 0;
}

多线程之线程同步（互斥锁、信号量、条件变量和读写锁​）
CodeAllen嵌入式
12-08 905
多线程编程的时候经常会发生公共资源被抢夺而造成问题。通常将“多个线程同时访问某一公共资源”的现象称为“线程间产生了资源竞争”或者“线程间抢夺公共资源”，线程间竞争资源往往会导致程序的运行结果出现异常，感到匪夷所思，严重时还会导致程序运行崩溃。幸运地是，Linux 提供了很多种解决方案，确定各个线程可以同步访问进程提供的公共资源（简称“线程同步”）。所谓线程同步，简单地理解就是：当一个线程访问某公共资源时，其它线程不得访问该资源，它们只能等待此线程访问完成后，再逐个访问该资源。
linux读写锁_共享内存读写锁
m0_74282605的博客
11-15 220
（版权归原文作者所有，侵权留言联系删除）原文作者：全栈程序员站长。
将读写锁放到共享内存，实现进程之间对于同一文件的读写操作
CHYabc123456hh的博客
01-06 2901
思路 将读写锁和读写锁的属性以及一个用于存储共享内存的地址的int型变量三者封装成一个struct结构 将这个结构体放到共享内存中，以及将读写锁的属性设置成全局性质，然后使用这个属性初始化锁，以及将锁的地址关联到结构体的内存地址这个变量 定义一个销毁函数，用于退出进程的时候，将内存空间销毁，以及删除对应的变量 定义读写函数，读函数读取文件的内容，输出文件的内容；写函数，以追加的方式，向指定文件中写入数据 测试：使用fork创建父子两个进程，定义一个for循环，循环5次之后，退出循环并且执行销毁函数
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
07-07
说明：编译时加上参数 -lrt -lpthread 要不然找不到库文件
多线程编程（1）：共享内存与锁
小明的博客
03-09 4466
1、什么是共享内存 共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一样。而如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同
Linux多线程同步机制—读写锁(Read-Write Lock)
最新发布
wjianwei666的专栏
07-09 1157
读写锁（Read-Write Lock）是一种线程同步机制，用于管理对共享资源的访问。与互斥锁（Mutex）不同，读写锁允许多个线程同时以读模式访问共享资源，但只允许一个线程以写模式访问资源。这种机制特别适用于读操作远多于写操作的场景，可以显著提高程序的并发性能。自定义实现读写锁代码需要开发者更深入地理解读写锁的底层实现原理。完全自行实现读写锁的逻辑，通过互斥锁、条件变量以及自定义的读计数和写标志来管理读写操作的同步。// 定义读写锁结构体// 互斥锁，用于保护读写锁的内部状态。
Linux线程同步详解：互斥锁、条件变量与信号灯
"这篇文档详细介绍了Linux环境下的线程同步技术，主要涉及pthread库的使用，包括线程的创建、退出、线程私有数据、线程同步（互斥量、条件变量、信号灯）以及线程终止等相关系统函数。作者在编写智能相机动态库的...
进程间通信IPC的关键技术：信号灯与互斥锁
该领域的知识点极其广泛，涉及多种通信方式，其中最典型的方式包括信号量、互斥锁和共享内存等。下面将详细介绍这些知识点。 1. 进程间通信（IPC） 在现代操作系统中，进程间通信是一个核心概念。它允许不同进程...
【多线程】临界区，互斥量，信号量，条件变量，事件以及区别
小鱼菜鸟的博客
10-04 714
目录 互斥量(互斥锁)和信号量(PV) 信号和信号量 信号量与条件变量 临界区与互斥量 总结 Linux和windows临界区 互斥量(互斥锁)和信号量(PV) 多任务间同步的方式包括关中断，调度器上锁， 互斥量(mutex),信号量，消息队列几种， 其中互斥量和信号量使用使用方式相近，连概念和实现都有些近似， 所以没有扎实操作系统背景...
线程同步=互斥锁+条件变量+信号量+文件锁(文件记录锁和文件锁) 死锁
qq_42024067的博客
10-16 900
（6）线程同步：目前实现线程同步的主要方式就是：互斥量、条件变量、信号量 线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。 linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 互斥量（互斥锁） 　　在Linux操作系统中，用户层面上编程使用的所有锁都是建议锁，不具有强制性，因此访问共享数据的所有线程（进程）都应该先加锁才能访问。 　　互斥量提供...
linux无亲缘关系进程间通信(互斥锁+条件变量+共享内存)
07-07
使用互斥锁+条件变量+共享内存的模式实现linux下亲缘关系间进程间同步通信 说明编译时加上 -lrt -lpthread参数
信号量对共享内存上锁示例代码
09-08
信号量对共享内存上锁示例代码 producer.c - 服务器程序，创建资源 custom.c - 客户端程序，访问资源 服务器对内存进行修改，客户端可以实时看到服务器输入的内容。
共享内存中使用条件变量
weixin_43856737的博客
08-10 425
共享内存中使用条件变量
linux进程共享内存读写锁,Linux-C-day-5-读写锁
weixin_33622085的博客
05-08 1409
读写锁当一个进程正在读或者修改某个文件的某个部分时，组织其他进程修改同一个文件或者同一个文件的某个区域。对于Linux来说一切皆是文件，包括IO设备共享内存；接口int fcntl(int fd, int cmd, struct flock *lock)；表示锁操作；fd：表示文件描述符；cmd：表示命令，F_GETLK：表示获取锁；设置锁：F_SETLK，用于加解锁；F_SETLKW用于设置加解...
互斥锁 try_lock 自旋锁 读写锁 原子操作 共享内存
饭真好吃的博客
08-05 1385
锁
linux 共享内存 读写锁,linux posix 读写锁+共享内存demo
weixin_39868248的博客
05-01 317
读写锁主要用于数据读操作比写操作频繁，且数据的实时性要求不高的场景使用gcc 编译的时候加上参数 -lrt -lpthread////////////////////////////////////////////////////server.c//////////////////////////////////////////////////////////////////////#includ...
linux共享内存条件变量,信号，信号量，锁，条件变量，消息通信，共享内存，RPC （一）...
weixin_39690097的博客
05-11 151
在实际项目当中，经常需要把一个功能分成多个子模块实现。那么，这些子模块之间该如何关联起来呢？静态地看，模块可以看作一组完成相同功能的函数；而动态地看，模块可以是一个独立的进程、线程或者一个中断服务或者信号服务例程。根据不同的具体业务实现，它们之间可能是静态调用、动态互斥、同步、唤醒等关系。静态的调用很好实现，上层的函数调用底层的函数即可。那么，动态互斥、同步、唤醒等关系，又该如何实现呢？这就设计到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值