Le mot-clé de l'élément Go est localisé : canal chan

La validation HTML fait référence à la validation HTML. Il s'agit d'un processus d'analyse de documents HTML et de marquage des erreurs et du code non standard en les comparant aux règles HTML standard. Les pages Web sont rendues à l'aide de HTML, et HTML lui-même adopte les spécifications HTML comme règles et normes. Validez le code HTML sur plusieurs standards de navigateur !

chan

chan est également appelé canal. Sa forme est similaire à un tuyau. Le contenu est envoyé par une extrémité et lu par l'autre extrémité. Ce qui suit décrit comment définir un canal :

var 变量名 chan dataType

Lors de la définition d'un canal, vous devez spécifier le type de données, ce qui signifie que seules les variables du type de données spécifié sont autorisées à passer par le canal.

Initialiser le canal

Lors de l'initialisation des variables de type de canal dans Golang, le canal peut être divisé en deux situations, l'une est un canal tamponné et l'autre est un canal non tamponné.
Ce qui suit est une introduction aux méthodes d'initialisation dans les deux situations suivantes :

// 初始化不带缓冲的通道，通道中数据类型是intvar ch1 = make(chan int)// 初始化带10个缓冲的通道，通道中数据类型是stringvar ch2 = make(chan string,10)

Une autre façon d'écrire est de définir et d'initialiser le canal,

// 定义通道，并给通道初始化8个缓冲ch3 ：= make(chan int ,8)// 定义通道，并初始化为不带缓冲通道ch4 := make(chan string)

Affectation de canal

La lecture et l'écriture sur le canal peuvent entrer dans un état de blocage.

1. Un canal sans mise en mémoire tampon se bloquera lors de l'écriture. Le blocage ne prendra fin que lorsque les informations du canal seront lues.

2. Canal mis en mémoire tampon, chaque fois que des informations sont écrites sur le canal, la longueur du canal sera augmentée de 1, et chaque fois que les informations sont lues avec succès sur le canal, la longueur du canal sera diminuée par 1. Si la longueur du canal est égale à la longueur du tampon du canal, continuer à écrire des informations sur le canal entraînera le blocage du programme ; si la longueur du canal est inférieure à la longueur du tampon du canal, l'écriture des informations sur le canal ne provoquera pas de blocage ; Si la longueur du canal est de 5, l'écriture d'informations sur le canal pour la sixième fois entraînera le blocage du programme lorsque le canal n'a pas été lu.

Le format de syntaxe pour l'écriture du canal est :

var ch = make(chan string,10)// 将字符串”hello"写入到通道中，通道长度加1ch <- "hello"

Lire le canal

Le canal est vide
1. Si le canal n'est pas fermé, le programme entrera dans un état de blocage et attendra que les informations soient écrites sur le canal
2. Le canal a été fermé et ne bloquera pas. La valeur initiale du type de données dans le canal (données sales) est renvoyée. Par exemple, lorsque le canal est chan int, la valeur de retour est 0. Lorsque le canal est chan. chaîne, la valeur de retour est vide.
La chaîne n'est pas vide
1. Le canal n'est pas fermé. Lisez les informations du canal une fois la lecture terminée, continuez l'exécution
. 2. Le canal a été fermé. Lisez les informations du canal une fois. Une fois la lecture terminée, passez à l'opération de canal de lecture

 : Utiliser la lecture d'assertion. Obtenez la valeur dans le canal, vérifiez s'il y a encore du contenu dans le canal et déterminez si le canal a été fermé. Lorsqu'il n'y a aucune information dans le canal et que le canal a été fermé, la valeur ok est fausse lorsque le canal. n'est pas fermé, mais il n'y a aucune information dans le canal, le programme bloquera, s'il y a du contenu dans le canal, la valeur ok est vraie.

val,ok := <-ch

Une autre façon de lire la chaîne sans utiliser d'assertions

Écrire et lire la chaîne

val := <-ch

Lecture sans mise en mémoire tampon Exemple de méthode de chaîne :

Résultat de sortie :

package mainimport (    "fmt")func main() {    // 定义一个不带缓冲的通道，通道中数据类型是int
    var c = make(chan int)    // 开启一个携程，读取通道中的内容
    go func() {
        fmt.Println("写入信息是：", <-c)
    }()    // 向通道中写入数据
    c <- 1}

Lors de la lecture et de l'écriture d'un canal mis en mémoire tampon, tant que la longueur des données dans le canal n'est pas supérieure à la longueur du tampon, il n'apparaîtra pas de blocage, mais lors de la lecture d'un canal mis en mémoire tampon et qu'il n'y a aucun contenu dans le canal, le programme entrera toujours dans l'état de blocage. Par conséquent, les canaux mis en mémoire tampon n’affectent que les écritures. Voici un exemple :

写入信息是： 1

Les informations de sortie sont :

package mainimport (    "fmt")func main() {    var c = make(chan int, 3)
    c <- 1
    c <- 2
    c <- 3
    //c <- 4
    fmt.Println("end")
}

Lors de l'écriture d'un contenu sur un canal avec 3 tampons, puisqu'il n'est écrit que 3 fois, le canal La longueur est exactement égal à la longueur du tampon, et le programme n'est pas bloqué. Lorsque le commentaire devant c

end

Communication coroutine

Une variable de type de canal est essentiellement une adresse, comme le montre l'exemple de code suivant :

Résultat de sortie :

package mainimport (    "fmt")func main() {    var c = make(chan int, 3)
    fmt.Println(c)
}

Ainsi, lorsque la variable de type canal est passée dans la fonction en paramètre, la valeur dans le canal peut être modifiée directement dans la fonction. Bien que la variable de type chan soit une adresse, golang ne permet pas l'utilisation de l'opérateur valeur (*) pour faire fonctionner la variable de type chan. Mais si vous utilisez d'abord l'opérateur d'adresse (&) sur la variable de type chan, puis utilisez l'opérateur de valeur (*), cette méthode d'opération peut toujours s'exécuter normalement, mais cela ne signifie pas grand-chose à moins que votre objectif ne soit dans l'appel de fonction, redéfinir une variable de type chan pour remplacer la variable d'origine.

0xc042072080

Ces fonctionnalités de chan peuvent réaliser efficacement la fonction de synchronisation entre les coroutines. Le canal sans tampon est une attente de tolérance zéro, qui peut réaliser une synchronisation forcée ; le canal avec tampon est une certaine attente de tolérance et peut réaliser une synchronisation qui permet une certaine différence de temps.

Exemple de communication inter-coroutine simple :

Les informations de sortie sont :

package mainimport (    "fmt"
    "time")func main() {    var c = make(chan int)    go func() {
        fmt.Println("待命模式：")        // 读取通道时产生阻塞，等待其他协程向通道写入信息
        fmt.Println("命令代码是：", <-c)
    }()    go func() {        // 延时3秒，向通道中写入信息
        time.Sleep(time.Second * 3)
        fmt.Println("发送命令：")
        c <- 8
        close(c)
    }()
    time.Sleep(time.Second * 5)
    fmt.Println("执行完成")
}

Recommandations associées :

待命模式：
发送命令：
命令代码是： 8
执行完成

Validation HTML Validation HTML_HTML/Xhtml_Production de pages Web

Compétences HTML compilation_CSS/HTML

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!