Structure de données concurrentes du langage Go : optimisation des performances des files d'attente et des piles

Dans le langage Go, les performances des files d'attente et des piles peuvent être obtenues grâce aux optimisations suivantes : Utilisez sync.Mutex et sync.Cond pour implémenter des files d'attente simultanées afin de garantir la sécurité des opérations de lecture et d'écriture. Utilisez les packages sync.Mutex et atomiques pour implémenter des piles simultanées afin de garantir l'atomicité des mises à jour du pointeur supérieur. Dans des cas pratiques, un traitement simultané efficace est obtenu grâce à des tâches de traitement simultanées de file d'attente et de pile.

Structures de données simultanées en langage Go : optimisation des performances des files d'attente et des piles

En Go, les files d'attente et les piles sont des structures de données couramment utilisées. Toutefois, dans les scénarios à forte concurrence, l'implémentation par défaut peut ne pas répondre aux exigences de performances. Cet article explique comment utiliser les primitives de concurrence intégrées du langage Go pour optimiser les performances des files d'attente et des piles.

File d'attente optimisée

Go fournit les primitives sync.Mutex et sync.Cond pour implémenter des files d'attente simultanées. Voici une file d'attente simultanée implémentée à l'aide de sync.Mutex et 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
            }
        }()
    }
}

Pile optimisée

rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!