go-diodes源码阅读--单生产者,单消费者无锁队列(1)

起因

今天在扩展我们自己的日志库,突然发现一个很有意思的说法(我们日志库基于zerolog做的二次开发)

Thread-safe, lock-free, non-blocking writer
If your writer might be slow or not thread-safe and you need your log producers to never get slowed down by a slow writer, you can use a diode.Writer as follow:
You will need to install code.cloudfoundry.org/go-diodes to use this feature.

第一个印象就是使用了go-diodes这个库,就达到了Thread-safe, lock-free, non-blocking writer效果。沟起了好奇心,然后看了下go-diodes库的代码只有不到1k左右,决定花1-2小时通读下,以期达到减少zerolog达来的黑洞感,也能更好地使用它。

从第一个生产者--消费者demo入手

这是一个生产者,消费者模型。我们用channel也可以很容易地实现这个模型,通过阅读下面的源代码解密这么做和channel比哪些不同点。

// 1.NewOneToOne
d := diodes.NewOneToOne(1024, diodes.AlertFunc(func(missed int) {
    log.Printf("Dropped %d messages", missed)
}))

// writer
go func() {
    for i := 0; i < 2048; i++ {
        // Warning: Do not use i. By taking the address,
        // you would not get each value
        j := i
        // 2.Set
        d.Set(diodes.GenericDataType(&j))
    }
}()

// reader
poller := diodes.NewPoller(d)
for {
    i := poller.Next()
    fmt.Println(*(*int)(i))
}

单生产者--单消费者无锁队列 数据结构

  • 很精简,其中```writeIndex uint64 ``标记生产都的位置
  • readIndex uint64 标记消费都的位置
  • alerter Alerter 丢数据调用的回调函数
  • buffer []unsafe.Pointer 存放任意类型的指针slice,这点学习下
type OneToOne struct {
    buffer     []unsafe.Pointer
    writeIndex uint64
    readIndex  uint64
    alerter    Alerter
}

初始化函数: 查看NewOneToOne初始化做了什么?

构造OneToOne结构体,buffer里面是unsafe.Pointer类型的slice。alerter是出错回调函数

func NewOneToOne(size int, alerter Alerter) *OneToOne {
    if alerter == nil {
        alerter = AlertFunc(func(int) {})
    }

    return &OneToOne{
        buffer:  make([]unsafe.Pointer, size),
        alerter: alerter,
    }
}

Write: .Set做了什么?

  • idx := d.writeIndex % uint64(len(d.buffer)) 使用取余符号把slice当成环使用
  • newBucket := &bucket{...} 生成指针变量并赋值
  • d.writeIndex++移动下写的位置
  • atomic.StorePointer(&d.buffer[idx], unsafe.Pointer(newBucket)) 线程安全的指针赋值方式,相当于下面的写法。
lock()
d.buffer[idx] = newBucket
unlock()
  • 总结:使用atomic包里面的原子变量函数,实行高效操作。
// Set sets the data in the next slot of the ring buffer.
func (d *OneToOne) Set(data GenericDataType) {
    idx := d.writeIndex % uint64(len(d.buffer))

    newBucket := &bucket{
        data: data,
        seq:  d.writeIndex,
    }
    d.writeIndex++

    atomic.StorePointer(&d.buffer[idx], unsafe.Pointer(newBucket))
}

Write: .Set中的疑问--如果读得慢写得快,如何?

Set里面没有任何判断条件,从代码上来看,Set里面的逻辑是直接覆盖没读取的数据(你没看错,数据没被及时读取就gg)。

Read: NewPoller初始化做了什么?

这里面初始化代码用了uber最佳编程实践描述过的一个技巧,感兴趣可自行查看。

func NewPoller(d Diode, opts ...PollerConfigOption) *Poller {
    p := &Poller{
        Diode:    d,
        interval: 10 * time.Millisecond,
        ctx:      context.Background(),
    }

    for _, o := range opts {
        o(p)
    }

    return p
}

Read: Next函数--读取迭代器

迭代器代码,用了sleep防止cpu一样空转。context如果取消直接退出。真正取数据的还是TryNext函数,等会儿看下。

// Next polls the diode until data is available or until the context is done.
// If the context is done, then nil will be returned.
func (p *Poller) Next() GenericDataType {
    for {
        data, ok := p.Diode.TryNext()
        if !ok {
            if p.isDone() {
                return nil
            }

            time.Sleep(p.interval)
            continue
        }
        return data
    }
}

Read: TryNext函数

TryNext主要作用是从buffer里面读取数据。

  1. idx := d.readIndex % uint64(len(d.buffer)) 计算读下标
  2. result := (*bucket)(atomic.SwapPointer(&d.buffer[idx], nil)) 原子交换变量
    当作于
lock()
result := d.buffer[idx]
d.buffer[idx] = nil
unlock()
  1. result.seq < d.readIndex 判断
  2. d.alerter.Alert(int(dropped)) 会善意地提醒你,它丢了多少条数据
func (d *OneToOne) TryNext() (data GenericDataType, ok bool) {
    // Read a value from the ring buffer based on the readIndex.
    idx := d.readIndex % uint64(len(d.buffer))
    result := (*bucket)(atomic.SwapPointer(&d.buffer[idx], nil))

    // When the result is nil that means the writer has not had the
    // opportunity to write a value into the diode. This value must be ignored
    // and the read head must not increment.
    if result == nil {
        return nil, false
    }

    // When the seq value is less than the current read index that means a
    // value was read from idx that was previously written but has since has
    // been dropped. This value must be ignored and the read head must not
    // increment.
    //
    // The simulation for this scenario assumes the fast forward occurred as
    // detailed below.
    //
    // 5. The reader reads again getting seq 5. It then reads again expecting
    //    seq 6 but gets seq 2. This is a read of a stale value that was
    //    effectively "dropped" so the read fails and the read head stays put.
    //    `| 4 | 5 | 2 | 3 |` r: 7, w: 6
    //
    if result.seq < d.readIndex {
        return nil, false
    }

    // When the seq value is greater than the current read index that means a
    // value was read from idx that overwrote the value that was expected to
    // be at this idx. This happens when the writer has lapped the reader. The
    // reader needs to catch up to the writer so it moves its write head to
    // the new seq, effectively dropping the messages that were not read in
    // between the two values.
    //
    // Here is a simulation of this scenario:
    //
    // 1. Both the read and write heads start at 0.
    //    `| nil | nil | nil | nil |` r: 0, w: 0
    // 2. The writer fills the buffer.
    //    `| 0 | 1 | 2 | 3 |` r: 0, w: 4
    // 3. The writer laps the read head.
    //    `| 4 | 5 | 2 | 3 |` r: 0, w: 6
    // 4. The reader reads the first value, expecting a seq of 0 but reads 4,
    //    this forces the reader to fast forward to 5.
    //    `| 4 | 5 | 2 | 3 |` r: 5, w: 6
    //
    if result.seq > d.readIndex {
        dropped := result.seq - d.readIndex
        d.readIndex = result.seq
        d.alerter.Alert(int(dropped))
    }

    // Only increment read index if a regular read occurred (where seq was
    // equal to readIndex) or a value was read that caused a fast forward
    // (where seq was greater than readIndex).
    d.readIndex++
    return result.data, true
}

注意事项

这个只能在两个go程间流转数据。一个write go程,一个read go程。

TODO

继续完善

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,511评论 1 330
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,495评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,595评论 0 225
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,558评论 0 190
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,715评论 3 270
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,672评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,112评论 2 291
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,837评论 0 181
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,417评论 0 228
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,928评论 2 232
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,316评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,773评论 2 234
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,253评论 3 220
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,827评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,440评论 0 180
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,523评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,583评论 2 249

推荐阅读更多精彩内容