Struktur data serentak bahasa Go: pengoptimuman prestasi baris gilir dan tindanan

Dalam bahasa Go, prestasi baris gilir dan tindanan boleh dicapai melalui pengoptimuman berikut: Gunakan penyegerakan.Mutex dan penyegerakan.Cond untuk melaksanakan baris gilir serentak untuk memastikan keselamatan operasi baca dan tulis. Gunakan penyegerakan.Mutex dan pakej atom untuk melaksanakan tindanan serentak bagi memastikan atomicity kemas kini penunjuk teratas. Dalam kes praktikal, pemprosesan serentak yang cekap dicapai melalui baris gilir serentak dan tugas pemprosesan tindanan.

Go struktur data serentak bahasa: pengoptimuman prestasi baris gilir dan tindanan

Dalam Go, baris gilir dan tindanan ialah struktur data yang biasa digunakan. Walau bagaimanapun, dalam senario konkurensi tinggi, pelaksanaan lalai mungkin tidak memenuhi keperluan prestasi. Artikel ini akan memperkenalkan cara menggunakan primitif serentak terbina dalam bahasa Go untuk mengoptimumkan prestasi baris gilir dan tindanan.

Baris Gilir Dioptimumkan

Go menyediakan primitif sync.Mutex dan sync.Cond untuk melaksanakan baris gilir serentak. Berikut ialah baris gilir serentak yang dilaksanakan menggunakan sync.Mutex dan sync.Cond: sync.Mutex 和 sync.Cond 原语来实现并发队列。这里是一个使用 sync.Mutex 和 sync.Cond 实现的并发队列：

type ConcurrentQueue struct {
    m     sync.Mutex
    items []interface{}
    conds sync.Cond
}

func (q *ConcurrentQueue) Enqueue(v interface{}) {
    q.m.Lock()
    defer q.m.Unlock()
    q.items = append(q.items, v)
    q.conds.Signal()
}

func (q *ConcurrentQueue) Dequeue() interface{} {
    q.m.Lock()
    defer q.m.Unlock()
    var v interface{}
    if len(q.items) > 0 {
        v = q.items[0]
        q.items = q.items[1:]
    }
    return v
}

通过使用 sync.Mutex 和 sync.Cond，我们可以在并发场景下安全地对队列进行读写操作。使用 Signal 信号可以唤醒等待的协程，从而提高效率。

优化栈

Go 中没有内置的并发栈实现。这里是一个使用 sync.Mutex 和 atomic 包实现的并发栈：

type ConcurrentStack struct {
    m sync.Mutex
    top *node
}

type node struct {
    data interface{}
    next *node
}

func (s *ConcurrentStack) Push(v interface{}) {
    s.m.Lock()
    defer s.m.Unlock()
    n := &node{data: v}
    n.next = s.top
    s.top = n
}

func (s *ConcurrentStack) Pop() interface{} {
    s.m.Lock()
    defer s.m.Unlock()
    if s.top == nil {
        return nil
    }
    v := s.top.data
    s.top = s.top.next
    return v
}

使用 atomic 包中的变量可以确保并发环境下的 top

func main() {
    q := ConcurrentQueue{}
    s := ConcurrentStack{}

    for i := 0; i < 1000; i++ {
        // 向队列中并发添加任务
        go func(i int) {
            q.Enqueue(i)
        }(i)
    }

    for i := 0; i < 1000; i++ {
        // 从队列中并发获取任务并推入栈中
        go func() {
            if v := q.Dequeue(); v != nil {
                s.Push(v)
            }
        }()
    }

    for i := 0; i < 1000; i++ {
        // 从栈中弹出任务并处理
        go func() {
            if v := s.Pop(); v != nil {
                // 处理任务 v
            }
        }()
    }
}

Timbunan Dioptimumkan

rrreee

Atas ialah kandungan terperinci Struktur data serentak bahasa Go: pengoptimuman prestasi baris gilir dan tindanan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!