Comment créer une chaîne en lecture seule dans Golang

Channel in Golang est un type de données spécial utilisé pour communiquer entre plusieurs goroutines. Chanel prend en charge deux opérations : l'envoi et la réception. L'opération d'envoi envoie une valeur au canal et l'opération de réception reçoit une valeur du canal.

Par défaut, le canal peut être lu et écrit, ce qui signifie que n'importe quelle goroutine peut envoyer et recevoir des opérations via le canal. Cependant, dans certains cas, nous devons restreindre certaines goroutines à recevoir uniquement mais pas envoyer, ou à envoyer uniquement mais pas recevoir. À l’heure actuelle, le canal en lecture seule peut s’avérer utile.

Un canal en lecture seule peut être lu par plusieurs goroutines en même temps, mais il est impossible d'y écrire. Il peut être utilisé pour implémenter des structures de données partagées en lecture seule afin d'éviter les problèmes de concurrence. Dans le langage Go, il existe une différence entre les canaux en lecture seule et les canaux ordinaires. Les canaux en lecture seule et les canaux en écriture seule sont de types différents.

Comment créer un canal en lecture seule

Un canal en lecture seule peut être créé en ajoutant le symbole <- devant le type de canal ordinaire. Par exemple, si nous avons un canal normal :

ch := make(chan int)

Pour le convertir en canal en lecture seule, nous pouvons l'écrire comme suit :

roCh := <-chan int(ch)

Ici, nous créons un canal en lecture seule dont le type est <- chan int , qui est un canal de type int en lecture seule. Notez que ce canal en lecture seule est d'un type différent du canal ordinaire d'origine, bien qu'ils soient tous deux utilisés pour transmettre des données de type int.

Implémentation d'un canal en lecture seule

Pour un canal en lecture seule, nous ne pouvons qu'en lire les données et ne pouvons pas y écrire de données. Par conséquent, lorsque nous utilisons un canal en lecture seule, nous devons faire attention à deux points :

1. Vous ne pouvez pas effectuer d'opérations d'envoi sur un canal en lecture seule, sinon cela provoquerait des erreurs de compilation.
2. Si nous convertissons un canal inscriptible en canal en lecture seule, alors le canal en lecture seule et le canal inscriptible pointeront vers le même bloc de données, de sorte que l'opération d'envoi peut être effectuée sur le canal inscriptible et transmise via le canal de lecture. -seul canal canal à recevoir.

Ce qui suit est un exemple simple qui démontre l'utilisation d'un canal en lecture seule :

package main

import "fmt"

func main() {
    ch := make(chan int, 10)
    for i := 0; i < 10; i++ {
        ch <- i
    }

    // 只读channel
    roCh := (<-chan int)(ch)

    // 从只读channel中读取数据
    for x := range roCh {
        fmt.Println("value:", x)
    }
}

Dans cet exemple, nous avons d'abord créé un canal inscriptible et y avons écrit 10 entiers. Ensuite, nous convertissons ce canal inscriptible en canal en lecture seule et en lisons les données via ce canal en lecture seule. Finalement, le programme affichera toutes les données écrites sur le canal.

Les canaux en lecture seule sont utilisés pour partager des structures de données

L'utilisation la plus courante des canaux en lecture seule est de partager des structures de données pour éviter les problèmes d'accès simultanés. Par exemple, nous pouvons utiliser un canal en lecture seule pour implémenter une file d'attente thread-safe qui ne peut lire que les données.

Ce qui suit est un exemple simple qui montre comment utiliser un canal en lecture seule pour implémenter une file d'attente thread-safe :

package main

import "fmt"

type Queue struct {
    roCh <-chan interface{}
}

func NewQueue(size int) *Queue {
    ch := make(chan interface{}, size)
    return &Queue{
        roCh: (<-chan interface{})(ch),
    }
}

func (q *Queue) Push(v interface{}) {
    ch := q.roCh.(chan<- interface{})
    ch <- v
}

func (q *Queue) Pop() interface{} {
    return <-q.roCh
}

func main() {
    q := NewQueue(10)
    for i := 0; i < 10; i++ {
        q.Push(i)
    }

    for i := 0; i < 10; i++ {
        fmt.Println(q.Pop())
    }
}

Dans cet exemple, nous implémentons une file d'attente, où la méthode Push est utilisée pour ajouter des éléments à la file d'attente. , La méthode Pop est utilisée pour afficher et renvoyer des éléments dans la file d'attente. Notez que notre file d'attente utilise un canal en lecture seule pour partager des données, garantissant ainsi la sécurité des accès simultanés.

Résumé

Le canal en lecture seule est un type spécial dans Golang, qui est utilisé pour restreindre certaines goroutines à recevoir uniquement des opérations et non à envoyer des opérations. Les canaux en lecture seule peuvent être utilisés pour implémenter des structures de données partagées en lecture seule afin d'éviter les problèmes de concurrence. Les canaux en lecture seule sont de types différents des canaux ordinaires et des canaux inscriptibles. Lorsque nous utilisons un canal en lecture seule, nous devons faire attention à ne pas effectuer d'opérations d'envoi sur un canal en lecture seule, sinon cela provoquerait des erreurs de compilation.

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!