Linux c实现一个线程安全的环形缓冲区

已于 2025-08-05 18:11:45 修改
阅读量970 收藏 7
点赞数
CC 4.0 BY-SA版权
文章标签： linux c语言 数据结构 环形缓冲区 环形队列
于 2023-07-18 18:46:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42161913/article/details/131793557
该代码实现了一个线程安全的环形队列，包括初始化、入队、出队、获取队列长度、判断队列是否为空、清空队列和销毁队列等操作。队列中的每个元素包含一个缓冲区和长度信息，支持动态分配和释放内存。测试部分展示了如何使用这个队列进行数据存储和读取。

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

ring_buffer.h

#ifndef _RING_BUFFER_H_
#define _RING_BUFFER_H_

#ifdef __cplusplus
extern "C"
{
#endif

#include <pthread.h>
#include <stdint.h>
#include <stddef.h>

    typedef struct ring_buffer ring_buffer;

    // 初始化环形缓冲区
    ring_buffer *ring_buffer_create(size_t capacity, size_t block_size);

    // 销毁环形缓冲区
    void ring_buffer_destroy(ring_buffer **pp_rb);

    // 向环形缓冲区中写入数据，返回 0 成功，负数失败，
    // 如果缓冲区满了，timeout_ms > 0: 最多阻塞timeout_ms毫秒；timeout_ms == 0: 立即返回；timeout_ms < 0: 永久阻塞直到有空间
    int ring_buffer_write(ring_buffer *rb, const void *data, size_t size, int timeout_ms);

    // 从环形缓冲区中读取数据，返回 0 成功，负数失败，
    // 如果缓冲区没有数据， timeout_ms > 0: 最多阻塞timeout_ms毫秒；timeout_ms == 0: 立即返回；timeout_ms < 0: 永久阻塞直到有数据
    int ring_buffer_read(ring_buffer *rb, void *data, size_t *size, int timeout_ms);

    // 读取但不删除数据，返回 0 成功，负数失败，
    // 如果缓冲区没有数据，timeout_ms > 0: 最多阻塞timeout_ms毫秒；timeout_ms == 0: 立即返回；timeout_ms < 0: 永久阻塞直到有数据
    int ring_buffer_peek(ring_buffer *rb, void *data, size_t *size, int timeout_ms);

    // 删除队首数据
    int ring_buffer_remove(ring_buffer *rb);

    // 获取当前缓冲区长度，成功返回缓冲区长度，失败返回-1
    int ring_buffer_length(ring_buffer *rb);

    // 判断缓冲区是否已满，-1 失败，0 未满，1 满
    int ring_buffer_is_full(ring_buffer *rb);

    // 判断缓冲区是否为空，-1 失败，0 不为空，1 为空
    int ring_buffer_is_empty(ring_buffer *rb);

    // 清空缓冲区
    void ring_buffer_clear(ring_buffer *rb);

#ifdef __cplusplus
}
#endif

#endif // _RING_BUFFER_H_

ring_buffer.c

#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <stdint.h>

#include "ring_buffer.h"

// 数据块结构体
struct ring_buffer_item
{
    void *data;  // 数据指针
    size_t size; // 数据大小
};

// 环形缓冲区结构体
struct ring_buffer
{
    struct ring_buffer_item *buffer; // 数据缓冲区
    size_t capacity;                 // 缓冲区容量（以数据块为单位）
    uint32_t count;                  // 当前缓冲区中数据块的数量
    size_t block_size;               // 每个数据块的固定大小（以字节为单位）
    size_t head;                     // 缓冲区头部索引
    size_t tail;                     // 缓冲区尾部索引
    pthread_mutex_t lock;
    pthread_cond_t cond_not_full;
    pthread_cond_t cond_not_empty;
};

// 初始化环形缓冲区
ring_buffer *ring_buffer_create(size_t capacity, size_t block_size)
{
    if (!capacity || !block_size)
        return NULL;

    ring_buffer *rb = malloc(sizeof(struct ring_buffer));
    if (!rb)
        return NULL;

    rb->buffer = malloc(capacity * sizeof(struct ring_buffer_item));
    if (!rb->buffer)
        goto fail;

    for (size_t i = 0; i < capacity; ++i)
    {
        rb->buffer[i].data = malloc(block_size);
        if (!rb->buffer[i].data)
        {
            // 释放已分配的 data
            for (size_t j = 0; j < i; ++j)
                free(rb->buffer[j].data);
            goto fail1;
        }
        rb->buffer[i].size = 0;
    }

    rb->capacity = capacity;
    rb->count = 0;
    rb->block_size = block_size;
    rb->head = 0;
    rb->tail = 0;

    pthread_mutex_init(&rb->lock, NULL);
    pthread_condattr_t attr;
    pthread_condattr_init(&attr);
    pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
    pthread_cond_init(&rb->cond_not_full, &attr);
    pthread_cond_init(&rb->cond_not_empty, &attr);
    pthread_condattr_destroy(&attr);
    return rb;

fail1:
    free(rb->buffer);
fail:
    free(rb);
    return NULL;
}

// 销毁环形缓冲区
void ring_buffer_destroy(ring_buffer **pp_rb)
{
    if (!pp_rb && !(*pp_rb))
        return;

    ring_buffer *rb = *pp_rb;
    for (size_t i = 0; i < rb->capacity; ++i)
    {
        free(rb->buffer[i].data);
    }

    free(rb->buffer);
    pthread_mutex_destroy(&rb->lock);
    pthread_cond_destroy(&rb->cond_not_full);
    pthread_cond_destroy(&rb->cond_not_empty);
    free(rb);
    *pp_rb = NULL;
}

// 超时时间转换为绝对时间
static int get_abs_timespec(struct timespec *abstime, uint32_t timeout_ms)
{
    struct timespec now;

    clock_gettime(CLOCK_MONOTONIC, &now);
    abstime->tv_sec = now.tv_sec + timeout_ms / 1000;
    abstime->tv_nsec = now.tv_nsec + (timeout_ms % 1000) * 1000000;
    if (abstime->tv_nsec >= 1000000000)
    {
        abstime->tv_sec += 1;
        abstime->tv_nsec -= 1000000000;
    }

    return 0;
}

// 写入数据
int ring_buffer_write(ring_buffer *rb, const void *data, size_t size, int timeout_ms)
{
    if (!rb || !data || !size || size > rb->block_size)
        return -1;

    int ret = 0;
    pthread_mutex_lock(&rb->lock);

    // 处理缓冲区满的情况
    while (rb->count == rb->capacity)
    {
        int wait_ret = 0;
        if (timeout_ms == 0)
        {
            ret = -2; // 缓冲区满且不等待
            break;
        }
        else if (timeout_ms > 0)
        {
            struct timespec abstime;
            get_abs_timespec(&abstime, timeout_ms);
            wait_ret = pthread_cond_timedwait(&rb->cond_not_full, &rb->lock, &abstime);
            if (wait_ret == ETIMEDOUT)
            {
                ret = -2; // 超时
                break;
            }
            else if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
        else
        { // timeout_ms < 0，永久等待
            wait_ret = pthread_cond_wait(&rb->cond_not_full, &rb->lock);
            if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
    }

    if (ret == 0)
    {
        memcpy(rb->buffer[rb->tail].data, data, size);
        rb->buffer[rb->tail].size = size;
        rb->tail = (rb->tail + 1) % rb->capacity;
        rb->count++;
        pthread_cond_signal(&rb->cond_not_empty);
    }

    pthread_mutex_unlock(&rb->lock);
    return ret;
}

// 读取数据
int ring_buffer_read(ring_buffer *rb, void *data, size_t *size, int timeout_ms)
{
    if (!rb || !data || !size)
        return -1;

    int ret = 0;
    pthread_mutex_lock(&rb->lock);

    while (rb->count == 0)
    {
        int wait_ret = 0;
        if (timeout_ms == 0)
        {
            ret = -2;
            break;
        }
        else if (timeout_ms > 0)
        {
            struct timespec abstime;
            get_abs_timespec(&abstime, timeout_ms);
            wait_ret = pthread_cond_timedwait(&rb->cond_not_empty, &rb->lock, &abstime);
            if (wait_ret == ETIMEDOUT)
            {
                ret = -2;
                break;
            }
            if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
        else
        {
            wait_ret = pthread_cond_wait(&rb->cond_not_empty, &rb->lock);
            if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
    }

    if (ret == 0)
    {
        memcpy(data, rb->buffer[rb->head].data, rb->buffer[rb->head].size);
        *size = rb->buffer[rb->head].size;
        rb->buffer[rb->head].size = 0;
        rb->head = (rb->head + 1) % rb->capacity;
        rb->count--;
        pthread_cond_signal(&rb->cond_not_full);
    }

    pthread_mutex_unlock(&rb->lock);
    return ret;
}

// 获取队首数据
int ring_buffer_peek(ring_buffer *rb, void *data, size_t *size, int timeout_ms)
{
    if (!rb || !data || !size)
        return -1;

    int ret = 0;
    pthread_mutex_lock(&rb->lock);

    while (rb->count == 0)
    {
        int wait_ret = 0;
        if (timeout_ms == 0)
        {
            ret = -2;
            break;
        }
        else if (timeout_ms > 0)
        {
            struct timespec abstime;
            get_abs_timespec(&abstime, timeout_ms);
            wait_ret = pthread_cond_timedwait(&rb->cond_not_empty, &rb->lock, &abstime);
            if (wait_ret == ETIMEDOUT)
            {
                ret = -2;
                break;
            }
            if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
        else
        {
            wait_ret = pthread_cond_wait(&rb->cond_not_empty, &rb->lock);
            if (wait_ret != 0)
            {
                ret = -1;
                break;
            }
        }
    }

    if (ret == 0)
    {
        memcpy(data, rb->buffer[rb->head].data, rb->buffer[rb->head].size);
        *size = rb->buffer[rb->head].size;
        ret = 0;
    }

    pthread_mutex_unlock(&rb->lock);
    return ret;
}

// 删除队首数据
int ring_buffer_remove(ring_buffer *rb)
{
    if (!rb)
        return -1;

    pthread_mutex_lock(&rb->lock);
    if (rb->count > 0)
    {
        rb->buffer[rb->head].size = 0;
        rb->head = (rb->head + 1) % rb->capacity;
        rb->count--;
    }

    pthread_cond_signal(&rb->cond_not_full);
    pthread_mutex_unlock(&rb->lock);
    return 0;
}

// 获取当前缓冲区长度
int ring_buffer_length(ring_buffer *rb)
{
    if (!rb)
        return -1;

    pthread_mutex_lock(&rb->lock);
    int length = rb->count;
    pthread_mutex_unlock(&rb->lock);
    return length;
}

// 判断缓冲区是否已满
int ring_buffer_is_full(ring_buffer *rb)
{
    if (!rb)
        return -1;

    pthread_mutex_lock(&rb->lock);
    int is_full = (rb->count == rb->capacity) ? 1 : 0;
    pthread_mutex_unlock(&rb->lock);
    return is_full;
}

// 判断缓冲区是否为空
int ring_buffer_is_empty(ring_buffer *rb)
{
    if (!rb)
        return -1;

    pthread_mutex_lock(&rb->lock);
    int is_empty = (rb->count == 0) ? 1 : 0;
    pthread_mutex_unlock(&rb->lock);
    return is_empty;
}

// 清空缓冲区
void ring_buffer_clear(ring_buffer *rb)
{
    if (!rb)
        return;

    pthread_mutex_lock(&rb->lock);
    for (size_t i = 0; i < rb->capacity; ++i)
    {
        memset(rb->buffer[i].data, 0, rb->block_size);
        rb->buffer[i].size = 0;
    }
    rb->count = 0;
    rb->head = 0;
    rb->tail = 0;
    pthread_cond_signal(&rb->cond_not_full);
    pthread_mutex_unlock(&rb->lock);
}

测试 main.c ：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>

#include "ring_buffer.h"

#define TEST_CAPACITY 4
#define TEST_BLOCK_SIZE 16

// 全局统计变量
static int total_tests = 0;
static int passed_tests = 0;
static int failed_tests = 0;

void print_result(const char *test_name, int result)
{
    total_tests++;
    if (result)
        passed_tests++;
    else
        failed_tests++;

    printf("%s: %s\n", test_name, result ? "通过" : "失败");
}

// 用于阻塞测试的全局变量
ring_buffer *rb_block;

// 线程1：尝试出队（缓冲区为空，应该阻塞，等到有数据后成功返回）
void *dequeue_block_thread(void *arg)
{
    char out[TEST_BLOCK_SIZE];
    size_t out_size = sizeof(out);
    int ret = ring_buffer_read(rb_block, out, &out_size, -1); // 永久阻塞
    if (ret == 0 && strcmp(out, "block") == 0)
    {
        printf("15. 阻塞出队线程: 成功出队数据: %s\n", out);
        pthread_exit((void *)1);
    }
    else
    {
        printf("15. 阻塞出队线程: 出队失败\n");
        pthread_exit((void *)0);
    }
}

// 线程2：尝试入队（缓冲区已满，应该阻塞，等到有空间后成功返回）
void *enqueue_block_thread(void *arg)
{
    char data[TEST_BLOCK_SIZE] = "block2";
    int ret = ring_buffer_write(rb_block, data, strlen(data) + 1, -1); // 永久阻塞
    if (ret == 0)
    {
        printf("16. 阻塞入队线程: 成功入队数据: %s\n", data);
        pthread_exit((void *)1);
    }
    else
    {
        printf("16. 阻塞入队线程: 入队失败\n");
        pthread_exit((void *)0);
    }
}

int test()
{
    ring_buffer *rb = NULL;
    char data[TEST_BLOCK_SIZE];
    char out[TEST_BLOCK_SIZE];
    size_t out_size;
    int ret;

    // 初始化
    rb = ring_buffer_create(TEST_CAPACITY, TEST_BLOCK_SIZE);
    if (!rb)
    {
        printf("初始化环形缓冲区失败\n");
        return -1;
    }

    // 检查是否为空
    print_result("检查缓冲区是否为空", ring_buffer_is_empty(rb) == 1);

    // 入队
    strcpy(data, "hello");
    ret = ring_buffer_write(rb, data, strlen(data) + 1, 0);
    print_result("入队数据", ret == 0);

    // 检查长度
    int length = ring_buffer_length(rb);
    print_result("检查缓冲区长度", length == 1);

    // 出队
    memset(out, 0, sizeof(out));
    out_size = sizeof(out);
    ret = ring_buffer_read(rb, out, &out_size, 0);
    print_result("出队数据", ret == 0 && strcmp(out, "hello") == 0);

    // 检查是否为空
    print_result("检查缓冲区是否为空", ring_buffer_is_empty(rb) == 1);

    // 多次入队
    int all_ok = 1;
    for (int i = 0; i < TEST_CAPACITY; ++i)
    {
        sprintf(data, "data%d", i);
        if (ring_buffer_write(rb, data, strlen(data) + 1, 0) != 0)
        {
            all_ok = 0;
            break;
        }
    }
    print_result("多次入队", all_ok);

    // 检查是否已满
    print_result("检查缓冲区是否已满", ring_buffer_is_full(rb) == 1);

    // 入队溢出测试
    ret = ring_buffer_write(rb, "overflow", 9, 0);
    print_result("入队溢出测试", ret < 0);

    // Peek 测试
    memset(out, 0, sizeof(out));
    out_size = sizeof(out);
    ret = ring_buffer_peek(rb, out, &out_size, 0);
    print_result("Peek 测试", ret == 0 && strncmp(out, "data0", 5) == 0);

    // Remove 测试
    print_result("Remove 测试", ring_buffer_remove(rb) == 0);

    // 检查长度
    length = ring_buffer_length(rb);
    print_result("检查缓冲区长度", length == TEST_CAPACITY - 1);

    // 清空缓冲区
    ring_buffer_clear(rb);
    print_result("清空缓冲区", ring_buffer_is_empty(rb) == 1);

    // 销毁缓冲区
    ring_buffer_destroy(&rb);
    printf("销毁缓冲区: 完成\n");

    // ========== 阻塞/超时功能测试 ==========

    // 出队阻塞测试
    rb_block = ring_buffer_create(2, TEST_BLOCK_SIZE);
    if (!rb_block)
    {
        printf("初始化环形缓冲区失败\n");
        return -1;
    }

    pthread_t tid1;
    void *thread_ret = NULL;
    pthread_create(&tid1, NULL, dequeue_block_thread, NULL);

    // 主线程睡眠1秒，确保子线程已阻塞
    sleep(1);

    // 入队数据，唤醒阻塞的出队线程
    strcpy(data, "block");
    ring_buffer_write(rb_block, data, strlen(data) + 1, 0);

    pthread_join(tid1, &thread_ret);
    print_result("出队阻塞测试", (int)(size_t)thread_ret == 1);

    // 入队阻塞测试
    // 先填满缓冲区
    ring_buffer_write(rb_block, "full1", 6, 0);
    ring_buffer_write(rb_block, "full2", 6, 0);

    pthread_t tid2;
    pthread_create(&tid2, NULL, enqueue_block_thread, NULL);

    // 主线程睡眠1秒，确保子线程已阻塞
    sleep(1);

    // 出队一个数据，唤醒阻塞的入队线程
    out_size = sizeof(out);
    ring_buffer_read(rb_block, out, &out_size, 0);

    pthread_join(tid2, &thread_ret);
    print_result("入队阻塞测试", (int)(size_t)thread_ret == 1);

    // 出队超时测试
    struct timeval tv1, tv2;
    long elapsed_ms;

    ring_buffer_clear(rb_block); // 确保缓冲区为空
    out_size = sizeof(out);
    gettimeofday(&tv1, NULL);
    ret = ring_buffer_read(rb_block, out, &out_size, 1000); // 1秒超时
    gettimeofday(&tv2, NULL);
    elapsed_ms = (tv2.tv_sec - tv1.tv_sec) * 1000 + (tv2.tv_usec - tv1.tv_usec) / 1000;
    print_result("出队超时测试", ret < 0);
    printf("出队超时实际耗时: %ld ms\n", elapsed_ms);

    // 入队超时测试
    ring_buffer_write(rb_block, "full3", 6, 0);
    ring_buffer_write(rb_block, "full4", 6, 0);
    gettimeofday(&tv1, NULL);
    ret = ring_buffer_write(rb_block, "timeout", 8, 1000); // 1秒超时
    gettimeofday(&tv2, NULL);
    elapsed_ms = (tv2.tv_sec - tv1.tv_sec) * 1000 + (tv2.tv_usec - tv1.tv_usec) / 1000;
    print_result("入队超时测试", ret < 0);
    printf("入队超时实际耗时: %ld ms\n", elapsed_ms);

    // 清理
    ring_buffer_destroy(&rb_block);

    return 0;
}

int main()
{
    printf("==== 环形缓冲区单元测试开始 ====\n");
    test();
    printf("==== 环形缓冲区单元测试结束 ====\n");

    // 打印统计信息
    printf("==== 测试统计 ====\n");
    printf("总测试数: %d\n", total_tests);
    printf("成功数: %d\n", passed_tests);
    printf("失败数: %d\n", failed_tests);

    return 0;
}
[Linux] 基于环形队列的生产者消费者模型
Darling_sheeps的博客
10-20 422
void Get(int &out)----消费者消费数据，P操作->从环形队列里面取数据->V操作。void Put(int &in)----生产者生产数据，P操作->往环形队列中放置数据->V操作。生产者生产数据：申请格子信号量----生产数据----释放数据信号量。消费者消费数据：申请数据信号量----消费数据----释放格子信号量。初始时，环形队列中全是空格：生产者要在空位置处生产数据；
【Linux多线程】一个基于环形队列实现的案例
广西彭于晏的博客
08-03 448
sem_t 是信号量（Semaphore）的数据类型，用于在多线程或多进程环境中实现线程同步和资源控制。信号量是一个计数器，用来控制对共享资源的访问。它主要有两个基本操作：wait 和 post，也被称为 P 操作和 V 操作。wait 操作用于申请资源并等待资源可用，若资源不可用，则线程或进程进入阻塞状态。post 操作用于释放资源，使得其他线程或进程可以继续执行。
嵌入式常用数据结构——ringbuffer环形缓冲区(线程安全版本带锁)
最新发布
qq_39642740的博客
06-26 938
本模块实现了一个**线程安全**的**环形缓冲区**（RingBuffer），适用于音频数据、串口通信、生产者-消费者等场景。完整的.c和.h文件已经提供，核心特点包括：
linux 线程安全队列
tedious的专栏
04-06 727
#ifdef WIN32#include #else#include #include #endif#include #include #include #include using namespace std;//这个是线程安全的队列，Synchronized类的实现在下面template class SyncQueue:public Synchronized{public:      
基于Linux的多线程安全队列
weixin_34224941的博客
12-30 120
线程队列头文件 threadqueue.h #ifndef THREADQUEUE_H_ .#define THREADQUEUE_H_ #include <pthread.h> #include <iostream> using std::cout; using std::endl; c...
linux c 环形队列,环形队列解决生产消费问题
weixin_39703926的博客
05-16 197
#include int n=2048,n1=2048,n2=2048;uint8_t Count=0;uint8_t f=0;int val=0;void ADC_DATA_CALLBACK(uint32_t u32UserData){n=n1;n1=n2;n2=DrvADC_GetConversionData(1);if(n2-n>650){DrvGPIO_ClrBit(E_PORT2,...
Linux多线程系列-2-条件变量的使用（线程安全队列的实现）
weixin_30367543的博客
07-09 184
多线程情况下，往往需要使用互斥变量来实现线程间的同步，实现资源正确共享。 linux下使用如下变量和函数 //条件变量 pthread_cond_t int pthread_cond_init (pthread_cond_t *c, const pthread_condattr_t *a) int pthread_cond_wait (pthread_cond_t *c,...
Linux C 数据结构——队列
热门推荐
知秋一叶
12-28 1万+
还是先放这张图，以便对比和理解：      队列是限制在两端进行插入操作和删除操作的线性表，允许进行存入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”。当线性表中没有元素时，称为“空队”。特点：先进先出（FIFO）。
Linux C 高性能串口通信实战：多线程+环形缓冲区设计
05-28
Linux C高性能串口通信的实现，依赖于多线程的设计来提高数据处理的并行度，以及环形缓冲区的设计来优化数据传输的效率和稳定性。通过精心设计和优化，可以在保证通信质量的前提下，大幅度提升系统的性能。
linux 多线程环形缓冲区,[多线程]环形缓冲区以及多线程条件同步
weixin_42261100的博客
05-08 791
1、环形缓冲区(下面生产者消费者的例子使用)使用一段内存空间作为缓冲区，维护两个指针，一是读指针，指向缓冲空间的第一个可读位置；二是写指针，指向空间的第一个空位置。读取一个数据后，读指针+1，当指针位置超出缓冲区域则指向缓冲区域的头位置(置0)；写入一个数据后，写指针+1，当指针位置超出缓冲区域则指向缓冲区域的头位置(置0)；由于空间循环利用，故称为环形缓冲区。空间满和空都是读指针位置等于写指针位...
环形队列实现
04-25
实现环形队列 原文：http://blog.csdn.net/billow_zhang/article/details/4420789
【Linux C/C++开发】队列缓存-环形缓冲区(包含C++ QT代码)
05-07
环形缓冲区的设计和实现是Linux C/C++开发中的一个基础而重要的知识点，它涉及内存管理、多线程编程、数据结构等多方面的知识。理解并熟练掌握环形缓冲区的原理和实现，对于进行高效的数据处理和多线程程序开发具有...
linux下C语言实现多线程通信—环形缓冲区,可用于生产者(producer)/消费者(consumer)
qinjie的博客
08-25 1619
一、概念引入 日常生活中，每当我们缺少某些生活用品时，我们都会去超市进行购买，那么，你有没有想过，你是以什么身份去的超市呢？相信大部分人都会说自己是消费者，确实如此，那么既然我们是消费者，又是谁替我们生产各种各样的商品呢？当然是超市的各大供货商，自然而然地也就成了我们的生产者。如此一来，生产者有了，消费者也有了，那么将二者联系起来的超市又该作何理解呢？诚然，它本身是作为一座交易场所而诞生。 将上述场景例比到我们实际的软件开发过程中，经常会见到这样一幕：代码的某个模块负责生产数据（供货商），而生产出来的数据却
linux 串口环形缓冲区,环形缓冲区的实现原理（ring buffer）（小寿转载 ）
weixin_39796140的博客
05-09 840
在通信程序中，经常使用环形缓冲区作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。1、环形缓冲区的实现原理环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅...
【C++ 语言】线程安全队列 ( 条件变量 | 线程调度 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
01-17 1351
I . 线程简单使用 II . 互斥锁 III . 条件变量 线程同步 IV . 完整代码示例 006_ThreadSafeQueue.h 006_ThreadSafeQueue.cpp SafeQueue.h CMakeLists.txt 运行结果 V . 示例代码说明
实现线程安全的队列
hanhan的博客
06-13 2744
使用了互斥量和条件变量来保证线程安全。中推入了 10 个整数，每个整数之间间隔 100 毫秒。假设我们忽略构造、赋值、互换、拷贝，那么只剩下3组操作。中取出了 10 个整数，并输出了每个整数的值。2：front、back，用于查询队列中的元素。在这个示例代码中，我们定义了一个生产者函数。中推入数据和从中取出数据。，并在两个线程中分别调用。
【Linux】生产者消费者模型-基于环形队列实现
ly_6699的博客
08-04 675
在上篇博客[基于阻塞队列的生产者消费者模型](https://blog.csdn.net/ly_6699/article/details/98315588)中我介绍了什么是生产者消费者模型以及生产者-消费者模式，还没了解的可以戳链接查看。 基于阻塞队列的实现，虽然简单，但是对内存分配性能要求较高的程序是不适用的，因为该方式在push的时候，可能会分配存储空间用于存储新元素；在pop时，可能会释放废弃元素的存储空间。如此频繁的对缓冲区进行分配和释放会大大浪费使用该模式的性能。 本篇博客是提高内存分配性能的一
linux 队列和线程安全,linux 线程安全队列
weixin_35890173的博客
05-13 181
#ifdef WIN32#include #else#include #include #endif#include #include #include #include using namespace std;//这个是线程安全的队列，Synchronized类的实现在下面template class SyncQueue:public Synchronized{public:SyncQueue(...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值