无锁队列实现：Lock free queue 大比拼题目 （tp://coderpk.com/）

最新推荐文章于 2024-05-29 09:43:42 发布
最新推荐文章于 2024-05-29 09:43:42 发布
阅读量586 收藏
点赞数
分类专栏： 无锁设计

有人在微博上发起了挑战，貌似很碉堡的样子，特别还创建了一个网站：

http://coderpk.com/

一向对解决此类问题有所兴趣于是尝试了我的做法：

首先我想到的问题是我去设计一个纯粹的多读多写无锁队列，肯定吃力不讨好（这家伙必然是实现了这种算法），而且要实现这种算法估计要花不少时间，于是我将其进行了转化，要想比他好，减少竞争是必须的。可以知道的是atomic操作的竞争已经很小了 但是毕竟要花不少时间代价的 我们的目标是没有这些atomic或者说尽量少出现。第一反应便是切割，将一个一个完整的队列划分成N个份，而任意一份都是都是1读1写的队列，再这个上面进行一层封装，于是从外部看起来其实就是一个队列，其实内部是N个队列，效果是显著的，基本上快了2-3倍

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include "time_count.h"
#include "stdint.h"
const int count_per_thread_push = 100000000;
const float CPU_MHZ = 1596; //use cat /proc/cpuinfo get the value
const float CPU_tick_count_per_second = CPU_MHZ*1000*1000;
#define RING_BUFF_SIZE 65536
#define RING_BUFF_NUM 10
static __thread int __thread_id__ = -1;
typedef struct RingBuffer {
    unsigned long long *buffer;
    int head;
    int tail;
    int size;
    int po;
    int pu;
    pthread_mutex_t push_used;
    pthread_mutex_t pop_used;
} RingBuffer;
inline bool init_rb(struct RingBuffer* rb, int size) {
    rb->buffer = (unsigned long long *)malloc(sizeof(unsigned long long) * (size + 1));
    if (rb->buffer == NULL) {
        return false;
    }
    rb->head = 0;
    rb->tail = 0;
    rb->po   = 0;
    rb->pu   = 0;
    pthread_mutex_init(&(rb->push_used), NULL);
    pthread_mutex_init(&(rb->pop_used), NULL);
    rb->size = size + 1;
    return true;
}
inline void free_rb_buff(struct RingBuffer* rb) {
    if (rb) {
        if (rb->buffer) {
            free(rb->buffer);
        }
    }
}
inline bool rb_push(struct RingBuffer* rb, unsigned long long number) {
    if ((rb->tail + 1) % rb->size == rb->head) {
        return false;
    }
    rb->buffer[rb->tail] = number;
    rb->tail = (rb->tail + 1) % rb->size;
    return true;
}
inline bool rb_pop(struct RingBuffer* rb) {
    if (rb->tail == rb->head) {
        return true;
    }
    bool ret = (rb->buffer[rb->head] != 0);
    rb->head = (rb->head + 1) % rb->size;
    return ret;
}
struct lock_free_queue {
    void push(unsigned long long pop_time)
    {
        while (__thread_id__ == -1) {
            for(int i = pop_time % RING_BUFF_NUM; i < RING_BUFF_NUM; i = (i + 1) % RING_BUFF_NUM) {
                pthread_mutex_lock(&(rb[i].push_used));
                if (rb[i].pu == 0) {
                    rb[i].pu = 1;
                    __thread_id__ = i;
                    pthread_mutex_unlock(&(rb[i].push_used));
                    break;
                }
                pthread_mutex_unlock(&(rb[i].push_used));
           }
        }
        while(!rb_push(rb + __thread_id__, pop_time));
    };
    bool pop()
    {
        while (__thread_id__ == -1) {
            for(int i = 0; i < RING_BUFF_NUM; i++) {
                pthread_mutex_lock(&(rb[i].pop_used));
                if (rb[i].po == 0) {
                    rb[i].po = 1;
                    __thread_id__ = i;
                    pthread_mutex_unlock(&(rb[i].pop_used));
                    break;
                }
                pthread_mutex_unlock(&(rb[i].pop_used));
           }
        }
//        if(now%(1000000) == 0) {
//            printf("task get:%u,task write:%u,latency:%lf\n",
//                    m_head[now],rdtsc(),(rdtsc()-m_head[now])/CPU_tick_count_per_second);
//        }
        return rb_pop(rb + __thread_id__);
    };
    lock_free_queue()
    {
        for(int i = 0; i < RING_BUFF_NUM; i++) {
            init_rb(rb + i, RING_BUFF_SIZE);
        }
    };
    ~lock_free_queue()
    {
        for(int i = 0; i < RING_BUFF_NUM; i++) {
            free_rb_buff(rb + i);
        }
    }
    struct RingBuffer rb[RING_BUFF_NUM];
};
void* pop(void* queue)
{
    lock_free_queue* lfq = (lock_free_queue*)queue;
    do{
    }while(lfq->pop());
    return NULL;
}
void* push(void* queue)
{
    lock_free_queue* lfq = (lock_free_queue*)queue;
    for(int i=0;i<count_per_thread_push/4;++i)
    {
        unsigned long long now = rdtsc();
        lfq->push(now);
        lfq->push(now);
        lfq->push(now);
        lfq->push(now);
    }
    // new add for signal stop
    lfq->push(0);
    return NULL;
}
//void* push_end(void* queue)
//{
//    lock_free_queue* lfq = (lock_free_queue*)queue;
//    for(int i=0;i<1000;++i)
//    {
//        lfq->push(0);
//    }
//}
int main(void)
{
    pthread_t* thread_pop = (pthread_t*) malloc(10*sizeof( pthread_t));
    pthread_t* thread_push = (pthread_t*) malloc(10*sizeof( pthread_t));
    pthread_t* thread_push_end = (pthread_t*) malloc(sizeof( pthread_t));
    lock_free_queue lfq;
    for(int i=0;i<10;++i)
    {
        pthread_create(&thread_push[i],NULL,push,&lfq);
    }
    for(int i=0;i<10;++i)
    {
        pthread_create(&thread_pop[i],NULL,pop,&lfq);
    }
    for(int i=0;i<10;++i)		//make push end
    {
        pthread_join(thread_push[i],NULL);
    }
    //pthread_create(thread_push_end,NULL,push_end,&lfq); //push end signal
    for(int i=0;i<10;++i)	//wait pop quit
    {
        pthread_join(thread_pop[i],NULL);
    }
    if( NULL != thread_pop )
    {
        free(thread_pop);
        thread_pop = NULL;
    }
    if( NULL != thread_push )
    {
        free(thread_push);
        thread_push = NULL;
    }
    if( NULL != thread_push_end )
    {
        free( thread_push_end );
        thread_push_end = NULL;
    }
}
本文出自： http://www.codeday.net, 原文地址： http://www.codeday.net/?p=162, 感谢原作者分享。
 
后来我自己加入计时代码，及使其可编译运行。 g++ -o lockfreeq lockfreequeue_forfunny.c -lpthread
 

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

//#include "time_count.h"
#include "stdint.h"
const int count_per_thread_push = 100000000;  //每个线程1亿次，10个线程就是那coderpk.com上的10亿次
float CPU_MHZ = 1596.0; //use cat /proc/cpuinfo get the value
float CPU_tick_count_per_second = CPU_MHZ*1000*1000;
#define RING_BUFF_SIZE 65536
#define RING_BUFF_NUM 10
static __thread int __thread_id__ = -1;
typedef struct RingBuffer {
    unsigned long long *buffer;
    int head;
    int tail;
    int size;
    int po;
    int pu;
    pthread_mutex_t push_used;
    pthread_mutex_t pop_used;
} RingBuffer;

__u64 rdtsc()

{
        __u32 lo,hi;
        __asm__ __volatile__

        (
         "rdtsc":"=a"(lo),"=d"(hi)

        );

        return (__u64)hi<<32|lo;

}

 

inline bool init_rb(struct RingBuffer* rb, int size) {
    rb->buffer = (unsigned long long *)malloc(sizeof(unsigned long long) * (size + 1));
    if (rb->buffer == NULL) {
        return false;
    }
    rb->head = 0;
    rb->tail = 0;
    rb->po   = 0;
    rb->pu   = 0;
    pthread_mutex_init(&(rb->push_used), NULL);
    pthread_mutex_init(&(rb->pop_used), NULL);
    rb->size = size + 1;
    return true;
}
inline void free_rb_buff(struct RingBuffer* rb) {
    if (rb) {
        if (rb->buffer) {
            free(rb->buffer);
        }
    }
}
inline bool rb_push(struct RingBuffer* rb, unsigned long long number) {
    if ((rb->tail + 1) % rb->size == rb->head) {
        return false;
    }
    rb->buffer[rb->tail] = number;
    rb->tail = (rb->tail + 1) % rb->size;
    return true;
}
inline bool rb_pop(struct RingBuffer* rb) {
    if (rb->tail == rb->head) {
        return true;
    }
    bool ret = (rb->buffer[rb->head] != 0);
    rb->head = (rb->head + 1) % rb->size;
    return ret;
}
struct lock_free_queue {
    void push(unsigned long long pop_time)
    {
        while (__thread_id__ == -1) {
            for(int i = pop_time % RING_BUFF_NUM; i < RING_BUFF_NUM; i = (i + 1) % RING_BUFF_NUM) {
                pthread_mutex_lock(&(rb[i].push_used));
                if (rb[i].pu == 0) {
                    rb[i].pu = 1;
                    __thread_id__ = i;
                    pthread_mutex_unlock(&(rb[i].push_used));
                    break;
                }
                pthread_mutex_unlock(&(rb[i].push_used));
           }
        }
        while(!rb_push(rb + __thread_id__, pop_time));
    };
    bool pop()
    {
        while (__thread_id__ == -1) {
            for(int i = 0; i < RING_BUFF_NUM; i++) {
                pthread_mutex_lock(&(rb[i].pop_used));
                if (rb[i].po == 0) {
                    rb[i].po = 1;
                    __thread_id__ = i;
                    pthread_mutex_unlock(&(rb[i].pop_used));
                    break;
                }
                pthread_mutex_unlock(&(rb[i].pop_used));
           }
        }
//        if(now%(1000000) == 0) {
//            printf("task get:%u,task write:%u,latency:%lf\n",
//                    m_head[now],rdtsc(),(rdtsc()-m_head[now])/CPU_tick_count_per_second);
//        }
        return rb_pop(rb + __thread_id__);
    };
    lock_free_queue()
    {
        for(int i = 0; i < RING_BUFF_NUM; i++) {
            init_rb(rb + i, RING_BUFF_SIZE);
        }
    };
    ~lock_free_queue()
    {
        for(int i = 0; i < RING_BUFF_NUM; i++) {
            free_rb_buff(rb + i);
        }
    }
    struct RingBuffer rb[RING_BUFF_NUM];
};
void* pop(void* queue)
{
    lock_free_queue* lfq = (lock_free_queue*)queue;
    do{
    }while(lfq->pop());
    return NULL;
}
void* push(void* queue)
{
    lock_free_queue* lfq = (lock_free_queue*)queue;
    for(int i=0;i<count_per_thread_push/4;++i)
    {
        unsigned long long now = rdtsc();
        lfq->push(now);
        lfq->push(now);
        lfq->push(now);
        lfq->push(now);
    }
    // new add for signal stop
    lfq->push(0);
    return NULL;
}
//void* push_end(void* queue)
//{
//    lock_free_queue* lfq = (lock_free_queue*)queue;
//    for(int i=0;i<1000;++i)
//    {
//        lfq->push(0);
//    }
//}
int main(void)
{
    pthread_t* thread_pop = (pthread_t*) malloc(10*sizeof( pthread_t));
    pthread_t* thread_push = (pthread_t*) malloc(10*sizeof( pthread_t));
    pthread_t* thread_push_end = (pthread_t*) malloc(sizeof( pthread_t));
    lock_free_queue lfq;
   
    struct timeval tv_start, tv_end;
    int usec_delay;
    gettimeofday(&tv_start, NULL);
   
    for(int i=0;i<10;++i)
    {
        pthread_create(&thread_push[i],NULL,push,&lfq);
    }
    for(int i=0;i<10;++i)
    {
        pthread_create(&thread_pop[i],NULL,pop,&lfq);
    }
    for(int i=0;i<10;++i)  //make push end
    {
        pthread_join(thread_push[i],NULL);
    }
    //pthread_create(thread_push_end,NULL,push_end,&lfq); //push end signal
    for(int i=0;i<10;++i) //wait pop quit
    {
        pthread_join(thread_pop[i],NULL);
    }
    if( NULL != thread_pop )
    {
        free(thread_pop);
        thread_pop = NULL;
    }
    if( NULL != thread_push )
    {
        free(thread_push);
        thread_push = NULL;
    }
    if( NULL != thread_push_end )
    {
        free( thread_push_end );
        thread_push_end = NULL;
    }
   
    gettimeofday(&tv_end, NULL);
   
    usec_delay = 1000000 * (tv_end.tv_sec - tv_start.tv_sec)
        + (tv_end.tv_usec - tv_start.tv_usec);
       
    printf("need usec:%d\n",usec_delay);
}

yand789
关注
专栏目录
boost---使用无锁队列（多生产者/多消费者）
小米的修行之路
03-10 3319
一、构造一个无锁队列：boost::lockfree::queue： 1、第一个参数标识队列中元素类型； 2、第二个参数用来协助配置boost::lockfree::queue： （1）、boost::lockfree::fixed_sized是否为固定大小。默认是boost::lockfree::fixed_sized<false>，表示当你调用push时，如果此时已经没有空间...
lockfree queue
06-13
无锁队列适用于多生产多消费者环境，快速队列真正无锁适用于单生产单消费环境； 消息队列，消息托管队列；
lock free queue
wangzhicheng2013的专栏
08-11 529
#include <iostream> #include <string> #include <vector> #include <atomic> #include <chrono> #include <thread> #include <type_traits> #include <stdexcept&g...
无锁队列（Lock-Free Queue）
笨死的猪Blog
03-24 4693
无锁队列（Lock-Free Queue）是一种不使用锁机制（如互斥锁或读写锁）来实现线程安全的数据结构，是lock-free中最基本的数据结构。它通过复杂的原子操作（如CAS操作，在C++中，可以使用库提供的原子操作）来确保在多线程环境下的正确性和一致性。无锁队列的设计目标是在高并发场景下提供高性能的入队和出队操作，避免了锁机制带来的性能开销和潜在的死锁问题。对于多线程用户来说，无锁队列的入队和出队操作是线程安全的，无需再加锁控制。
无锁队列的实现
Hello World!
09-10 1361
原文 http://coolshell.cn/articles/8239.html 关于无锁队列的实现，网上有很多文章，虽然本文可能和那些文章有所重复，但是我还是想以我自己的方式把这些文章中的重要的知识点串起来和大家讲一讲这个技术。下面开始正文。 关于CAS等原子操作 在开始说无锁队列之前，我们需要知道一个很重要的技术就是CAS操作——Compare & Set，或是 Compa
lockfree-queue：基于数组的无锁队列
02-11
固定大小的无锁队列（2010） 队列是在生产者/消费者算法中广泛发现的抽象数据类型。 许多良好的实现都是锁死的，并且可能会与数千个并发线程在其上添加和使用数据的情况发生激烈争用。 上述技术可用于实现完全无锁的基于数组的队列： lockfree queue primitives typedef struct _queue_t *queue_t; queue_t queue_create(size_t); void *queue_dequeue(queue_t); int queue_enqueue(queue_t, void *); 队列的期望深度是在创建时由queue_create定义的， queue_dequeue返回元素地址，如果队列为空，则返回NULL ，要排队的元素的地址传递给queue_enqueue ，如果操作成功，则返回0 ，返回1如果队列已满。 内部数据结构，初始化：
evpp性能测试（3）: 对无锁队列boost::lockfree::queue和moodycamel::ConcurrentQueue做一个性能对比测试
热门推荐
聪明的解释器
04-09 1万+
我们使用[https://github.com/Qihoo360/evpp]项目中的`EventLoop::QueueInLoop(...)`函数来做这个性能测试。我们通过该函数能够将一个仿函数执行体从一个线程调度到另一个线程中执行。这是一个典型的生产者和消费者问题。 我们用一个队列来保存这种仿函数执行体。多个生产者线程向这个队列写入仿函数执行体，一个消费者线程从队列中取出仿函数执行体来执行。为了保证队列的线程安全
C++无锁（lock free）队列moodycamel::ConcurrentQueue
最新发布
qq_37464701的博客
05-29 1138
moodycamel::ConcurrentQueue一个用C++11实现的多生产者、多消费者无锁队列。它具有以下特点：1.快的让人大吃一惊，详见不同无锁队列之间的压测对比2.单头文件实现，很容易集成到你的项目中3.完全线程安全的无锁队列，支持任意线程数的并发4.用C++11实现，尽可能move元素，而不是copy元素5.模板化，无需专门处理指针，内部自动管理内存6.对元素类型或最大计数没有人为限制7.内存可以预先一次分配，也可以根据需要动态分配。
无锁队列的C++实现
05-26
一个无锁队列的C++实现。Miscellaneous scripts and things that dont merit their own repo. All under MIT License unless otherwise specified
Lock-free Queue and Ring Buffer
12-24
Lock-free Queue and Ring Buffer
freelockqueue（多线程不需要加锁的队列性能很高）
01-18
在多线程情况下，C#的队列入队和出队时需要现场同步，但这样会损失性能，此开源队列可以不需要同步，就能实现多线程操作，极大的提高了程序的运行效率
gringo:使用Go（golang.org）编写的精简无锁环形缓冲区实现的高性能极简队列
05-18
该项目不再维护-随时分叉该项目！ 格林戈 使用Go（golang.org）编写的简化的无锁环形缓冲区实现的高性能极简队列 当使用2个或更多goroutine进行操作时，GOMAXPROCS> = goroutine的数量，并且有足够的CPU内核来并行服务goroutine，这相当于使用通道构建的等效管道的吞吐量的大约6倍。
Lock-free队列（无图版)
smartcat2010的博客
02-29 1317
1. Introduction Improving applications with high-performance constraints has an obvious choice nowadays:Multithreading. Threads have been around for quite a long time. In the old days, when most com...
boost lockfree queue-boost无锁队列
qq_23350817的博客
05-07 4127
例子如下： #include <iostream> #include <boost/lockfree/queue.hpp> int main() { boost::lockfree::queue<int, boost::lockfree::fixed_sized<false> > queue(128); for (int i = 0;i < 10000;i++) queue.push(i); while (!queue.empty())
lock free queue的实现
wzq2009的专栏
07-25 485
#ifndef __ARRAY_LOCK_FREE_QUEUE_IMPL_MULTIPLE_PRODUCER_H__ #define __ARRAY_LOCK_FREE_QUEUE_IMPL_MULTIPLE_PRODUCER_H__ #include "atomic_ops.h" #include <assert.h> // assert() #include <sched.h> // sched_yield() #include "logger_factory.h" #incl
A fast lock-free queue for C++
专心-超越
09-24 4670
http://moodycamel.com/blog/2013/a-fast-lock-free-queue-for-c++#benchmarks // ©2013 Cameron Desrochers. // Distributed under the simplified BSD license (see the license file that // should have
【转】A Fast General Purpose Lock-Free Queue for C++
weixin_30329623的博客
09-15 112
From：http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++ So I've been bitten by the lock-free bug! After finishing mysingle-producer, single-consumer lock-free queue, I de...
并发编程-实现一个高并发的无锁队列（Lock-Free）
qq_27552579的博客
01-13 283
package com.ln.juc.custom; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import ja
Lock-Free Queue 理解
weixin_39801169的博客
03-14 426
Lock-Free 队列的设计目标是提高并发性能，因为在传统的锁保护的队列中，每次只能有一个线程对队列进行操作，其他线程必须等待，这会导致性能瓶颈。：在某些实现中，可能会出现 ABA 问题，其中一个线程在检查某个值时发现它是 A，然后在它有机会使用该值之前，另一个线程将其更改为 B，然后又将其改回 A。Lock-Free 队列的工作原理通常依赖于原子操作（atomic operations），这些操作保证了在多线程环境中对共享数据的访问是安全的，而不需要使用锁。
无锁队列与环缓冲：EffoCore项目实现详解
本文档主要探讨了无锁队列（Lock-free Queue）和环形缓冲区（Ring Buffer）两种在并发编程中的关键数据结构。无锁数据结构在多线程环境中具有重要的应用价值，因为它们旨在减少同步开销，提高系统的并发性能和稳定性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值