file d'attente de mise en œuvre du pipeline Golang

En langage Go, le canal est une structure de données très puissante. Il peut être utilisé pour la communication et la synchronisation entre les coroutines, mais dans le développement réel, nous n'utilisons généralement que ses fonctions de base. Dans cet article, je vais vous montrer comment implémenter une structure de données de file d'attente à l'aide de canaux.

1. Le concept de base du pipeline

Pipeline est une primitive de concurrence dans le langage Go, utilisée pour la transmission de données et la synchronisation entre les coroutines. Il est conçu comme une méthode de transmission de données bloquante, c'est-à-dire que pendant les opérations d'envoi et de réception, les coroutines d'envoi et de réception se bloqueront jusqu'à ce que l'opération de l'autre partie soit terminée avant de passer à l'opération suivante.

En langage Go, vous pouvez utiliser la fonction make() pour créer un pipeline. Il existe deux types de pipelines : avec et sans tampon. Les canaux tamponnés peuvent stocker une certaine quantité de données, tandis que les canaux non tamponnés ne peuvent envoyer et recevoir qu'en même temps.

Voici comment définir un tube de type chaîne sans tampon :

ch := make(chan string)

2. Le concept de base de la file d'attente

La file d'attente (file d'attente) est une structure de données commune qui suit le principe du premier entré, premier sorti (FIFO) Gérer données. Les files d'attente peuvent ajouter des données à une extrémité de la file d'attente et supprimer des données à l'autre extrémité. L'opération d'insertion est également appelée mise en file d'attente et l'opération de suppression est également appelée retrait de la file d'attente.

En langage Go, nous pouvons utiliser des tranches pour implémenter la structure de données de file d'attente. Pour les opérations de mise en file d'attente et de retrait de la file d'attente, vous pouvez utiliser la fonction append() et l'opération de coupe de la tranche.

Voici comment définir une file d'attente de type chaîne :

queue := []string{}

3. L'idée d'implémenter des files d'attente via des pipelines

Maintenant que nous avons une certaine compréhension des concepts de base des pipelines et des files d'attente, nous pouvons commencez à réfléchir à la façon de les utiliser. Les Pipes implémentent des files d'attente.

Tout d'abord, nous devons définir un tube de type chaîne tamponnée et utiliser une coroutine pour écouter en continu ce tube. Lorsqu'il y a des données dans le pipeline, nous devons les ajouter à la file d'attente, sinon nous continuons d'attendre.

Deuxièmement, nous devons définir deux fonctions : mettre en file d'attente et retirer la file d'attente. Dans la fonction de mise en file d'attente, nous envoyons la chaîne d'entrée au tube et attendons que la coroutine d'écoute l'ajoute à la file d'attente. Dans la fonction dequeue, nous retirons le premier élément de la file d'attente et renvoyons sa valeur. Si la file d'attente est vide, une chaîne vide est renvoyée.

Enfin, nous devons écrire un programme de test simple pour vérifier si notre implémentation est correcte.

Voici le code spécifique au processus d'implémentation :

package main

import "fmt"

func main() {
    q := NewQueue()

    q.Enqueue("Hello")
    q.Enqueue("World")
    q.Enqueue("Golang")

    fmt.Println(q.Dequeue())
    fmt.Println(q.Dequeue())
    fmt.Println(q.Dequeue())
}

func NewQueue() *Queue {
    // 创建一个带缓冲的字符串类型管道
    ch := make(chan string, 100)

    // 启动一个协程持续监听管道
    go func() {
        for s := range ch {
            // 将管道中的字符串加入到队列中
            queue = append(queue, s)
        }
    }()

    return &Queue{ch: ch}
}

// 全局队列变量
var queue []string

type Queue struct {
    ch chan string
}

func (q *Queue) Enqueue(s string) {
    q.ch <- s
}

func (q *Queue) Dequeue() string {
    if len(queue) == 0 {
        return ""
    }

    s := queue[0]
    queue = queue[1:]

    return s
}

Dans le code ci-dessus, nous créons d'abord un tube de type chaîne tamponnée et démarrons une coroutine pour écouter ce tube. Dans la coroutine, lorsqu'il y a une chaîne dans le tube, nous l'ajoutons à la file d'attente.

Dans la fonction NewQueue(), nous utilisons un pipeline pour implémenter une file d'attente et renvoyer le pointeur de la file d'attente. Dans la fonction Enqueue(), nous envoyons la chaîne d'entrée dans le tube. Dans la fonction Dequeue(), nous supprimons le premier élément de la file d'attente et renvoyons sa valeur. Si la file d'attente est vide, une chaîne vide est renvoyée.

Enfin, nous avons écrit un programme de test simple pour tester si notre implémentation de file d'attente est correcte.

4. Résumé

Dans cet article, j'ai présenté comment utiliser les tubes pour implémenter la structure de données de file d'attente. L'utilisation de pipelines peut implémenter la fonction de file d'attente de manière plus concise et efficace, et offre de bonnes performances de concurrence, ce qui est très approprié pour l'environnement de développement du langage Go. J'espère que cet article pourra aider les débutants à mieux comprendre les concepts de pipelines et de files d'attente dans le langage Go, et pourra également fournir quelques idées pour résoudre les problèmes rencontrés dans le développement réel.

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!