LINUX-多线程同步

已于 2022-09-25 20:02:47 修改
阅读量176 收藏
点赞数
分类专栏： linux进程 文章标签： c++ 开发语言
于 2022-09-12 14:53:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaopengvv/article/details/126809335
版权

1. 互斥量mutex

1.1 主要应用函数

  1. pthread_mutex_init函数
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
    const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

功能：销毁或者创建mutex
参数：

  • restrict 约束该块内存区域对应的数据，只能通过后面的变量进行访问和修改
  • mutex互斥量
  • attr互斥量的属性，可以不考虑，传NULL
  1. pthread_mutex_destroy函数
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能：销毁mutex指针指向的锁对象。
参数：mutex传入的锁
常量初始化，此时可以使用init

  1. pthread_mutex_lock函数
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

功能：给共享资源加锁
参数：metux init 初始化的锁
如果当前未锁，成功，该线程给加锁。
如果已经加锁，阻塞等待！

互斥量使用步骤：

  • 初始化
  • 加锁
  • 执行逻辑
  • 解锁

互斥量使用demo01:

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thr1(void *arg)
{
    while(1) {
        // 先上锁
        pthread_mutex_lock(&mutex);
        printf("hello");
        sleep(rand() % 3);
        printf("world\n");
        // 释放锁
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);
    }
}

void *thr2(void *arg)
{
    while(1) {
        // 先上锁
        // 上锁的范围，称为临界区
        pthread_mutex_lock(&mutex);
        printf("HELLO");
        sleep(rand() % 3);
        printf("WORLD\n");
        // 释放锁
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);
    }
}

int main(int argc, char *argv[])
{
    pthread_t tid[2];
    pthread_create(&tid[0], NULL, thr1, NULL);
    pthread_create(&tid[0], NULL, thr2, NULL);

    pthread_join(tid[0], NULL);
    pthread_join(tid[1], NULL);
    return 0;
}

注意事项：加锁需要最小粒度，不要一直占用临界区。

互斥量使用demo01:

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

pthread_mutex_t mutex;

void *thr(void *arg)
{
    while(1) {
        pthread_mutex_lock(&mutex);
        printf("hello world.\n");
        sleep(30);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    pthread_t tid;
    pthread_create(&tid, NULL, thr, NULL);
    sleep(1);
    while(1) {
        int ret = pthread_mutex_trylock(&mutex);
        if (ret > 0) {
            printf("ret = %d, srrmsg:%s\n", ret, strerror(ret));
        }
        sleep(1);
    }
    return 0;
}

1.2 死锁

出现死锁的情况：

  • 锁了又锁，自己加了一次锁成功，又加了一次。
  • 交叉锁

解决办法：每个线程申请锁的顺序要一致
如果申请到一把锁，申请另外一把锁的时候失败了，应该释放已经拥有的锁。

2. 读写锁

2.1 基本概念

  1. 与互斥量类似，但是读写锁允许更高的并行性。
  2. 读写锁具备三种状态：
  • 读模式下加锁状态（读锁）
  • 写模式下加锁状态（写锁）
  • 不加锁状态
  1. 读写锁特性：写独占，读共享，写优先级高
  • 写模式加锁时，解锁前，所有对该锁加锁的线程都会被阻塞。
  • 读模式加锁时，线程以读模式对其加锁会成功；线程以写模式加锁会阻塞。
  1. 读写锁场景：
  • 线程A持有写锁，线程B请求读锁
    线程B阻塞
  • 线程A持有读锁，线程B请求写锁
    线程B阻塞
  • 线程A拥有读锁，线程B请求读锁
    线程B加锁成功
  • 线程A持有读锁，然后线程B请求写锁，然后线程C请求读锁
    线程BC均阻塞
    A释放后，B加锁
    B释放后，C加锁
  • 线程A持有写锁，然后线程B请求读锁，然后线程C请求写锁
    线程BC均阻塞
    A释放后，C加锁
    C释放后，B加锁

总结：读写锁的使用场景，适合读的场景多

2.2 主要应用函数

  1. 初始化读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_relockattr_t *restrict attr);
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
  1. 销毁读写锁
int pthread_rwlock_destory(pthread_rwlock_t *rwlock);
  1. 加锁
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 加读锁
int pthread_rwlock_wrlock(pthtread_rwlock_t *rwlcok); // 加写锁
  1. 释放锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

读写锁demo

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

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
int beginNum = 1000;

void *thr_write(void *arg)
{
    while(1) {
        pthread_rwlock_wrlock(&rwlock);
        printf("-----%s-----self----%lu----beginNum -----%d\n",
            __FUNCTION__, pthread_self(), ++beginNum);
        pthread_rwlock_unlock(&rwlock);
        sleep(3);
    }
    
    return NULL;
}

void *thr_read(void *arg)
{
    while(1) {
        pthread_rwlock_rdlock(&rwlock);
        printf("-----%s-----self----%lu----beginNum -----%d\n",
            __FUNCTION__, pthread_self(), beginNum);
        pthread_rwlock_unlock(&rwlock);
        sleep(3);
    }
    return NULL;
}

int main()
{
    int n = 8;
    int i = 0;
    pthread_t tid[8];
    for (i = 0; i < 5; i++) {
        pthread_create(&tid[i], NULL, thr_read, NULL);
    }

    for (; i < 8; i++) {
        pthread_creat(&tid[i], NULL, thr_write, NULL);
    }

    for (i = 0; i < 8; i++) {
        pthread_join(tid[i]);
    }
    return 0;
}

3. 条件变量

  1. 常用函数
  • pthread_cond_init函数
  • pthread_cond_destory函数
  • pthread_cond_timedwait函数 超时等待
  • pthread_cond_wait函数 超时不等待
  • phtread_cond_signal 唤醒至少一个阻塞在条件变量cond上的线程
  • phtread_cond_broadcast 唤醒阻塞在条件变量cond上的全部线程
  1. 条件变量demo1
    一个生产者和一个消费者
#include <cstdio>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <memory.h>
using namespace std;

int beginnum = 1000;

struct _ProdInfo {
    int num;
    struct _ProdInfo * next;
};

_ProdInfo *Head = nullptr;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thr_producter(void *arg)
{
    // 负责在链表添加数据
    while (1) {
        _ProdInfo *prod = (_ProdInfo *)malloc(sizeof(_ProdInfo));
        prod->num = beginnum++;
        printf("-------%s-------self=%lu-----%d\n",
            __FUNCTION__, pthread_self(), prod->num);

        pthread_mutex_lock(&mutex);
        prod->next = Head;
        Head = prod;
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);
        
        sleep(rand() % 4);
    }

    return nullptr;
}

void *thr_customer(void *arg)
{
    _ProdInfo *prod = nullptr;
    while (1) {
        // 获取链表数据
        pthread_mutex_lock(&mutex);
        if (Head == nullptr) {
            // 链表数据没有数据
            pthread_cond_wait(&cond, &mutex);
        }
        prod = Head;
        Head = Head->next;
        printf("-----%s-------self=%lu-----%d\n",
            __FUNCTION__, pthread_self(), prod->num);
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 4);
        free(prod);
    }
    return nullptr;
}

int main()
{
    pthread_t tid[2];
    pthread_create(&tid[0], nullptr, thr_producter, nullptr);
    pthread_create(&tid[1], nullptr, thr_customer, nullptr);

    pthread_join(tid[0], nullptr);
    pthread_join(tid[1], nullptr); 
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}
  1. 条件变量demo2
    一个生产者和多个消费者模型demo
#include <cstdio>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <memory.h>
using namespace std;

int beginnum = 1000;

struct _ProdInfo {
    int num;
    struct _ProdInfo * next;
};

_ProdInfo *Head = nullptr;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;


void *thr_producter(void *arg)
{
    // 负责在链表添加数据
    while (1) {
        _ProdInfo *prod = (_ProdInfo *)malloc(sizeof(_ProdInfo));
        prod->num = beginnum++;
        printf("-------%s-------self=%lu-----%d\n",
            __FUNCTION__, pthread_self(), prod->num);

        pthread_mutex_lock(&mutex);
        prod->next = Head;
        Head = prod;
        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond); // 唤醒阻塞的线程
        
        sleep(rand() % 2);
    }

    return nullptr;
}

void *thr_customer(void *arg)
{
    _ProdInfo *prod = nullptr;
    while (1) {
        // 获取链表数据
        pthread_mutex_lock(&mutex);
        while (Head == nullptr) { // 支持多个消费者
            // 链表数据没有数据，会有多个消费者阻塞在此处
            pthread_cond_wait(&cond, &mutex); // 添加条件变量
        }
        prod = Head;
        Head = Head->next;
        printf("-----%s-------self=%lu-----%d\n",
            __FUNCTION__, pthread_self(), prod->num);
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);
        free(prod);
    }
    return nullptr;
}

int main()
{
    pthread_t tid[3];
    pthread_create(&tid[0], nullptr, thr_producter, nullptr);
    pthread_create(&tid[1], nullptr, thr_customer, nullptr);
    pthread_create(&tid[2], nullptr, thr_customer, nullptr);

    pthread_join(tid[0], nullptr);
    pthread_join(tid[1], nullptr);
    pthread_join(tid[2], nullptr); 
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

4. 信号量

  1. 简介
    进化版的互斥锁（1->N）
    由于互斥锁的粒度比较大，如果我们希望在多个线程某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。
    信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
    在这里插入图片描述

  2. 常用函数
    sem_init函数
    sem_destroy函数
    sem_wait函数
    sem_trywait函数
    sem_timedwait函数
    sem_post函数

  3. 信号量demo

#include <cstdio>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <memory.h>
#include <semaphore.h>

sem_t blank,xfull;
const int SEMCNT = 5;
int queue[SEMCNT]; // 模拟饼框
int beginnum = 100;

void *thr_producter(void *arg)
{   
    int i = 0;
    while (1) {
        sem_wait(&blank); // 申请资源 blank--
        printf("-------%s------self = %lu-----num = %d\n",
            __FUNCTION__, pthread_self(), beginnum);
        queue[(i++)%SEMCNT] = beginnum++;
        sem_post(&xfull); // xfull++
        sleep(rand() % 2);
    }

    return nullptr;
}

void *thr_customer(void *arg)
{
    int i = 0;
    int num = 0;
    while (1) {
        sem_wait(&xfull); // xfull++
        num = queue[(i++)%SEMCNT];
        printf("------------%s------self = %lu-----num = %d\n",
            __FUNCTION__, pthread_self(), num);
        sem_post(&blank); // blank++
        sleep(rand() % 3);
    }
    return nullptr;
}

int main()
{
    sem_init(&blank, 0, SEMCNT);
    sem_init(&xfull, 0, 0); // 消费者一开始默认没有商品

    pthread_t tid[2];
    pthread_create(&tid[0], nullptr, thr_producter, nullptr);
    pthread_create(&tid[1], nullptr, thr_customer, nullptr);

    pthread_join(tid[0], nullptr);
    pthread_join(tid[1], nullptr);
    return 0;
}
知识搬运工Mr.zh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值