【Linux多线程】线程同步 与 生产者消费者模型（无锁化模型）

于 2024-08-17 11:28:16 发布
阅读量1k 收藏 25
点赞数 30
分类专栏： linux进阶 文章标签： linux 算法 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreaming_TI/article/details/141161335
版权

文章目录

1. Linux线程同步

1.1 条件变量

  • 当一个线程互斥地访问某个变量时，可能在其它线程改变状态之前，无法做任何操作。
  • 例如一个线程访问队列时，发现队列为空，它只能等待，只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量

1.2 同步概念与竞态条件

  • 同步：在保证数据安全的前提下，使线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题
  • 竞态条件：因为时序问题，而导致程序异常。

1.3 条件变量函数

① 初始化:

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
  • 参数：
    • cond：要初始化的条件变量
    • attr：NULL

② 销毁：

int pthread_cond_destroy(pthread_cond_t *cond)

③ 等待条件满足:

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
  • 参数：
    • cond：要在这个条件变量上等待
    • mutex：互斥量，后面详细解释

④ 唤醒等待:

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

示例代码1:

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

pthread_cond_t cond;
pthread_mutex_t mutex;

void *r1( void *arg )
{
	while (true){
		pthread_cond_wait(&cond, &mutex);
		printf("活动\n");
	}
} 

void *r2(void *arg )
{
	while (true) {
		pthread_cond_signal(&cond);
		sleep(1);
	}
}

int main( void )
{
	pthread_t t1, t2;
	pthread_cond_init(&cond, NULL);
	pthread_mutex_init(&mutex, NULL);
	pthread_create(&t1, NULL, r1, NULL);
	pthread_create(&t2, NULL, r2, NULL);
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
}

执行函数，有以下输出：

[root@localhost linux]# ./test.out
活动
活动
活动

示例代码2

直接利用condition_variable：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable> // 条件变量

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(char id, bool flag)
{
    for(int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lck(mtx);
        cv.wait(lck, [&] { return ready == flag; });

        std::cout << "ThreadId: "<< id << std::endl;
        ready = !ready;

        cv.notify_all();
    }
}

int main() {
    std::thread t1(print_id, '1', true);
    std::thread t2(print_id, '2', false);
 
    t1.join();
    t2.join();
    
    return 0;
}

执行结果：

在这里插入图片描述

1.4 为什么 pthread_ cond_ wait 需要互斥量

  • 条件等待是线程间同步的一种手段，如果只有一个线程，条件不满足，则会一直等待下去
  • 所以必须有一个线程通过某些操作，改变共享变量，使原先不满足的条件变得满足，并且正常通知等待在条件变量上的线程
  • 条件不会无缘无故的突然满足，一定会关联到共享数据的变化。所以必须要用互斥锁保护。
  • 没有互斥锁就无法安全的获取和修改共享数据

1.5 条件变量使用规范

一般使用条件变量可以通过以下的方式：

等待条件代码：

pthread_mutex_lock(&mutex);
while (条件为假）
pthread_cond_wait(cond, mutex);
修改条件
pthread_mutex_unlock(&mutex);

给条件发信号代码：

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);

2. 生产者消费者模型

关于生产者消费者模型的概念 与 代码实现，可以看下面的两篇文章：

  1. 基于互斥锁的生产者消费者模型
  2. 基于 BlockQueue（阻塞队列） 的 生产者消费者模型

3. 读者 写者 问题

3.1 读写锁

  • 在编写多线程时，有一种十分常见的情况：有些公共数据修改的机会较少。
  • 相比于改写，更多是执行读操作。 通常读的过程往往伴随着查找的操作，中间耗时长。给这种代码段加锁，会极大地降低程序效率。

有没有一种方法，可以更好的处理这种多读少写的情况呢？

有，即读写锁。

在这里插入图片描述

对上图进行解释，即：

  • 读锁（Shared Lock）：允许多个线程同时获得读锁，以进行读取操作，但在读锁被持有时，写锁无法获得。
  • 写锁（Exclusive Lock）：在写锁被持有时，其他线程既不能获得读锁也不能获得写锁。写锁保证独占访问以进行写操作。

3.2 读写锁的相关接口

设置读写优先：

int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *attr, int pref);
/*
pref 共有 3 种
Ⅰ PTHREAD_RWLOCK_PREFER_READER_NP (默认设置) 读者优先，可能会导致写者饥饿情况
Ⅱ PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先，目前有 BUG，导致表现行为和 Ⅰ 一致
Ⅲ PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先，但写者不能递归加锁
*/

初始化：

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr)

销毁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

加锁 / 解锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

下面写一个读写锁的简单示例：

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

// 共享资源
int shared_data = 0;

// 读写锁
pthread_rwlock_t rwlock;

// 读操作
void* read_operation(void* thread_id) {
    pthread_rwlock_rdlock(&rwlock);  // 获取读锁
    printf("Thread %ld reading data: %d\n", (long)thread_id, shared_data);
    // 模拟读取操作的延迟
    usleep(100000);
    pthread_rwlock_unlock(&rwlock);  // 释放锁
    return NULL;
}

// 写操作
void* write_operation(void* thread_id) {
    pthread_rwlock_wrlock(&rwlock);  // 获取写锁
    shared_data = (int)(long)thread_id * 10;
    printf("Thread %ld writing data: %d\n", (long)thread_id, shared_data);
    // 模拟写入操作的延迟
    usleep(100000);
    pthread_rwlock_unlock(&rwlock);  // 释放锁
    return NULL;
}

int main() {
    pthread_t threads[7];
    pthread_rwlockattr_t attr;

    // 初始化读写锁属性
    pthread_rwlockattr_init(&attr);
    // 设置读写锁属性（例如，锁的类型）
    pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NP);

    // 初始化读写锁
    pthread_rwlock_init(&rwlock, &attr);

    // 启动几个读线程
    for (long i = 1; i <= 5; ++i) {
        pthread_create(&threads[i-1], NULL, read_operation, (void*)i);
    }

    // 启动几个写线程
    for (long i = 1; i <= 2; ++i) {
        pthread_create(&threads[i+4], NULL, write_operation, (void*)i);
    }

    // 等待所有线程完成
    for (int i = 0; i < 7; ++i) {
        pthread_join(threads[i], NULL);
    }

    // 销毁读写锁
    pthread_rwlock_destroy(&rwlock);
    pthread_rwlockattr_destroy(&attr);

    return 0;
}

执行上面的代码，会有以下的执行结果：

Thread 1 reading data: 0
Thread 2 reading data: 0
Thread 3 reading data: 0
Thread 4 reading data: 0
Thread 5 reading data: 0
Thread 6 writing data: 10
Thread 7 writing data: 20
Thread 1 reading data: 20
Thread 2 reading data: 20
Thread 3 reading data: 20
Thread 4 reading data: 20
Thread 5 reading data: 20

4. 扩展：无锁化模型

无锁化编程（Lock-Free Programming）是一种并发编程技术，旨在避免使用传统的锁机制（如互斥锁、信号量等），从而减少锁带来的性能开销和复杂性。

  • 无锁编程适用于高并发环境，因为它可以显著提高程序的吞吐量和响应性。

4.1 基本概念

  1. 无锁的定义：

    • 在无锁编程中，算法或数据结构保证 至少有一个线程在有限时间内完成操作，而其他线程的操作不会导致全局进程的阻塞 。无锁化编程中的操作不使用传统的互斥锁机制，而是使用原子操作和算法保证线程安全。

  2. 无锁的优势：

    • 减少线程等待：由于不使用锁，线程不会因等待锁而被阻塞，从而减少了上下文切换的开销。
    • 提高并发性：无锁编程可以提高系统的吞吐量，因为多个线程可以并发地执行操作，不必等待其他线程完成。
    • 降低死锁风险：由于不使用锁，死锁和其他锁相关的问题（如优先级反转）不再是问题。

  3. 无锁编程的问题：

  • 复杂性：编写无锁算法通常比传统的锁算法要复杂得多，需要对并发和原子操作有深入的理解。
  • 可见性问题：在多核系统中，需要确保线程对共享数据的修改对其他线程是可见的，这通常通过原子操作来保证。
  • 性能开销：无锁算法可能在某些情况下引入额外的性能开销，如自旋等待的开销。

4.2 常见的无锁数据结构和算法

  1. 无锁队列（Lock-Free Queue）：

    • 无锁队列允许多个线程同时执行入队和出队操作，而不会导致阻塞。常用的实现方式包括基于环形缓冲区的队列和基于链表的队列。

  2. 无锁栈（Lock-Free Stack）：

    • 无锁栈是一种支持并发推入（push）和弹出（pop）操作的数据结构，通常实现为链表结构，每个操作都通过原子操作来实现。

  3. 无锁哈希表（Lock-Free Hash Table）：

    • 无锁哈希表允许并发地进行插入、删除和查找操作，常用的实现方式包括分段锁无锁哈希表和基于链表的无锁哈希表。

  4. 无锁计数器（Lock-Free Counter）：

    • 无锁计数器用于支持高并发的增量操作，通常使用原子操作来保证每次对计数器的更新都是安全的。

4.3 实现无锁编程的关键技术

  1. 原子操作：

    • 原子操作是无锁编程的基础，它保证了对共享数据的操作在执行时是不可分割的。在 C++ 中，std::atomic 提供了对原子操作的支持。

  2. 自旋锁（Spinlock）：

    • 自旋锁是一种轻量级的锁机制，线程在尝试获取锁时，会在一个小的循环中反复检查锁的状态，而不是被阻塞。虽然自旋锁本身不是无锁的，但在无锁编程中，自旋锁可以用于实现某些无锁算法的关键部分。

  3. CAS（Compare-And-Swap）操作：

    • CAS 是一种常用的原子操作，它用于比较一个值与预期值是否相等，如果相等则更新为新值。CAS 是许多无锁算法的核心操作。

① 示例：无锁栈的简单实现

#include <atomic>

template<typename T>
class LockFreeStack {
public:
    LockFreeStack() : head(nullptr) {}

    ~LockFreeStack() {
        while (Node* old_head = head.load()) {
            head.store(old_head->next);
            delete old_head;
        }
    }

    void push(const T& value) {
        Node* new_node = new Node(value);
        new_node->next = head.load();
        while (!head.compare_exchange_weak(new_node->next, new_node)) {
            // 如果 compare_exchange_weak 失败，说明 head 已经被其他线程修改了
            // 需要将 new_node->next 更新为当前 head 并重试
        }
    }

    bool pop(T& value) {
        Node* old_head = head.load();
        while (old_head && !head.compare_exchange_weak(old_head, old_head->next)) {
            // 如果 compare_exchange_weak 失败，说明 head 已经被其他线程修改了
            // 需要将 old_head 更新为当前 head 并重试
        }
        if (old_head) {
            value = old_head->data;
            delete old_head;
            return true;
        }
        return false;
    }

private:
    struct Node {
        T data;
        Node* next;
        Node(const T& value) : data(value), next(nullptr) {}
    };

    std::atomic<Node*> head;
};

在这个例子中，我们实现了一个无锁栈。std::atomic 用于保证对栈顶指针 head 的原子操作。compare_exchange_weak 是核心的无锁操作，用于在更新栈顶指针时避免数据竞争。

② 原子操作 atomic的使用

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>

// 原子计数器
std::atomic<int> counter(0);

// 线程函数：增加计数器
void incrementCounter(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main() {
    const int numThreads = 4;
    const int iterationsPerThread = 1000;

    // 启动多个线程，每个线程增加计数器的值
    std::vector<std::thread> threads;
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(incrementCounter, iterationsPerThread);
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    // 输出最终计数器的值
    std::cout << "Final counter value: " << counter.load() << std::endl;

    return 0;
}

4.4 总结

无锁化编程通过避免传统锁机制，能够提高程序的并发性和性能。它的核心在于使用原子操作和无锁算法来确保线程安全，而不是依赖于锁来保护共享资源。虽然无锁编程可以提供显著的性能优势，但它也带来了更高的复杂性；

卜及中
关注
专栏目录
多线程实现生产者与消费者模式
YANG
06-01 1万+
生产者-消费者模式的简介：在实际的软件开发过程中，我们将产生数据的模块称为生产者，处理数据的模块成为消费者。但仅有这两者还不够成为一个生产者-消费者模式，还需要有一个缓冲区（一段内存区域）作为中介，生产者产生的数据放入缓冲区，消费者从缓冲区读取数据并处理。（注：上述所说的模块是广义的，可以是类，函数，线程，进程等）我们可以将这二者之间的关系图表示出来：总结：我们用3-2-1的方法来简单描述一个生产者
Linux线程安全，死锁，生产消费模型，线程池
徐凤年llll的博客
12-02 927
然后你第二天准备去学习了，卷的不行，直接凌晨三点就跑过来，拿着钥匙进入自习室上自习了，然后卷了3小时之后，你想出来上个厕所，一打开门发现外面站的一堆人，都在叽叽喳喳的讨论谁先来的，怎么来的这么早？等你回来的时候，你又打开门，又来里面上了3小时自习，你感觉自己饿的不行了，在不吃饭就饿死在里面了，所以你打开门，准备出去吃饭了，然后突然你自己感觉负罪感直接拉满，我凌晨3点好不容易抢到自习室，现在离开是不太亏了，所以你又打开自习室回去上自习去了，别人当然竞争不过你呀！即为3种关系，两个角色，1个交易场所。
C++11 - 基于无锁队列的单生产者单消费者模型
HW140701的博客
04-22 3729
1 单生产者单消费者无锁队列 Github项目地址：https://github.com/cameron314/readerwriterqueue 2 多生产者多消费者无锁队列 另外这个作者还搞了一个并发的无锁队列， Github地址：https://github.com/cameron314/concurrentqueue 3 单生产者单消费者无锁模型 基于第一个项目的readerwrite...
生产者消费者之无锁队列
wangbuji的博客
03-10 1079
生产者消费者模型包含4种模式，本文主要讨论1:1，以linux内核2.6.24.4版本kfifo为例。 1:1, 1:n, n:n, n:1 kfifo的定义文件：kernel/kfifo.c kfifo的头文件： include/linux/kfifo.h 1. kfifo概述 kfifo是内核里面的一个First In First Out数据结构，它采用环形循环队列的数据结构来实现；它提供一个无边界的字节流服务，最重要的一点是，它使用并行无锁编程技术，即当它用于只有一个入队线程和一.
一篇文章带你搞定高性能的生产者-消费者模式：无锁的实现
南淮北安的博客
01-21 2139
用BlockigQueue队列实现生产者和消费者是一个不错的选择。它可以很自然地实现作为生产者和消费者的内存缓冲区。但是BlockigQueue队列并不是一个高性能的实现，它完全使用锁和阻塞等待来实现线程间的同步。在高并发场合，它的性能并不是特别的优越。就像之前我已经提过的：ConcurrentLinkedQueue是一个高性能的队列，但是BlockingQueue队列只是为了方便数据共享。 而ConcurrentLinkedQueue队列的秘诀就在于大量使用了无锁的CAS操作。同理，如果我们使用CAS来实
无锁生产者与消费者模型实例-线程
duanbin的博客
07-15 775
无锁的话就是要两个线程不能同时访问一个变量。那么这样就干脆用两个任务链表，如果在读队列里面的任务处理完成，同时写队列里面又有任务了，就交换两个队列，交换任务队列的动作由主线程来实现。基于这种思想代码如下： #include "public.h" #include <list> using namespace std; list<int>* queueMain; list...
JAVA高并发——生产者-消费者模式
码说芯语的博客
02-22 1098
生产者-消费者模型、无锁缓存框架Disruptor
无锁单生产者-单消费者循环队列
04-11
标题 "无锁单生产者-单消费者循环队列" 涉及到的是并发编程中的一个高级主题，它探讨了如何在多线程环境中高效地实现数据共享，尤其是在C++11标准下。C++11引入了许多新的特性，如线程库（）、原子操作（）等，使得...
linux上实现多进程和多线程实现同步互斥（源代码）
04-18
- 使用条件变量实现线程间的协作，如生产者消费者模型。 - 实现读写锁，允许多个读取线程并行，写入线程独占。 - 应用信号量控制并发访问的资源数量。 总结，Linux上的多进程和多线程编程涉及复杂的同步互斥操作，...
Linux下的多线程编程二（线程的同步与互斥）
snow_5288的博客
06-14 4562
一、什么叫做线程的同步与互斥？为什么需要同步与互斥？ 二、互斥量 三、条件变量 四、信号量 五、读写锁
并发模式之生产者消费者模式
mg0324的专栏
07-28 251
可以通过将存储的数据使用填充对齐到缓存行（64字节）大小，使得每个缓存行只存一个数据。阻塞队列来做内存缓冲区，但是由于使用了锁和阻塞等待来实现线程间的同步，所以新能不高。类型64位即8字节，补7个加上自己的一个工8个，合计64字节，刚好占一个缓存行大小）)就是典型的生产者消费者模式（其中任务是线程），其中内存缓冲区的实现使用的是。而LMAX公司开发了一套无锁实现的高性能生产者消费者模式的框架，叫做。生产者消费者模式是一个经典的多线程设计模式。例子（生产者生成数据，消费者计算数据平方）...
数据结构与算法之美学习笔记：54 | 算法实战（三）：剖析高性能队列Disruptor背后的数据结构和算法
最新发布
weixin_43597208的博客
02-27 1056
本节课程思维导图：Disruptor 你是否听说过呢？它是一种内存消息队列。从功能上讲，它其实有点儿类似 Kafka。不过，和 Kafka 不同的是，Disruptor 是线程之间用于消息传递的队列。它在 Apache Storm、Camel、Log4j 2 等很多知名项目中都有广泛应用。之所以如此受青睐，主要还是因为它的性能表现非常优秀。它比 Java 中另外一个非常常用的内存消息队列 ArrayBlockingQueue（ABS）的性能，要高一个数量级，可以算得上是最快的内存消息队列了。
无锁队列原理及实现（一）
wupeng4389151的博客
10-10 1548
无锁队列原理及实现（一）
（新思路）生产者消费者模型2（BlockingQueue的无锁解决方法）
rootlh的博客
09-02 713
通过阻塞队列来模拟生产者消费者模型，和synchronized（wait和notifyAll）、lock（condition）方法相比，效率更高，因为不需要人为加锁。 LinkedBlockingQueue的实现方式（无界队列，可以装到内存满为止） 1public class testLinkedBlockingQueue{2    //初始化阻塞队列容器（放产品）
C++ 11 无锁，使用atomic实现的生产者消费者模型
小罗的学习博客
02-27 1012
#include<iostream> #include<future> #include<atomic> #include<chrono> #include<list> #include<thread> using namespace std; //使用锁 int main(){ atomic<bool>...
并发无锁队列学习（单生产者单消费者模型）
weixin_33976072的博客
08-13 351
1、引言 本文介绍单生产者单消费者模型的队列。依据写入队列的内容是定长还是变长，分为单生产者单消费者定长队列和单生产者单消费者变长队列两种。单生产者单消费者模型的队列操作过程是不须要进行加锁的。生产者通过写索引控制入队操作，消费者通过读索引控制出队列操作。二者相互之间对索引是独享，不存在竞争关系。例如以下图所看到的： 2、单生产者单消费者定长队列 　　这样的队列要求每...
Java多线程实践：消费者-生产者模型解析与优化
"Java多线程中的消费者-生产者模型是一种经典的并发编程模式，用于解决两个或多个线程之间的同步问题。在这个模型中，生产者线程负责创建数据（产品），而消费者线程则负责处理这些数据。为了保证系统的稳定和高效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值