• LINUX-多线程同步

    1. 互斥量mutex

    1.1 主要应用函数

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

    • 1
    • 2
    • 3
    • 4

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

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

    • 1
    • 2

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

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

    • 1
    • 2
    • 3
    • 4

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

    互斥量使用步骤：

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

    互斥量使用demo01:

    #include 
#include 
#include 
#include 

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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

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

    互斥量使用demo01:

    #include 
#include 
#include 
#include 
#include 

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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    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
    • 2
    1. 销毁读写锁
    int pthread_rwlock_destory(pthread_rwlock_t *rwlock);

    • 1
    1. 加锁
    int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); // 加读锁
int pthread_rwlock_wrlock(pthtread_rwlock_t *rwlcok); // 加写锁

    • 1
    • 2
    1. 释放锁
    int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

    • 1

    读写锁demo

    #include 
#include 
#include 
#include 
#include 

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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    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 
#include 
#include 
#include 
#include 
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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    1. 条件变量demo2
      一个生产者和多个消费者模型demo
    #include 
#include 
#include 
#include 
#include 
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;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77

    4. 信号量

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

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

    3. 信号量demo

    #include 
#include 
#include 
#include 
#include 
#include 

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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
  • 相关阅读:
    分库分表利器：Sharding-JDBC、TDDL、Mycat选择与应用
    SOLIDWORKS --流体仿真篇
    5G车载网关让医院无人配送车“灵活“起来
    带你了解MySQL数据库(三)
    秒懂！用这10款思维导图软件，让头脑风暴如虎添翼！
    【Linux学习】05-2Linux上部署项目
    WPF 控件模板
    我的创作纪念日
    【巨杉数据库】银行流水查询系统设计
    基于JAVA农产品供销服务系统计算机毕业设计源码+系统+mysql数据库+lw文档+部署
  • 原文地址：https://blog.csdn.net/zhaopengvv/article/details/126809335