l'application de canal à sens unique « modèle de consommation productive »
La plupart des applications typique est un canal à sens unique, « modèle producteur-consommateur. »
Le soi-disant « modèle producteur-consommateur »: un module (fonction, etc.) responsable de la production des données, qui est responsable du traitement par un autre module (module ici est large, peut être une classe, fonction, coroutine, fils, processus etc.). module de génération de données, il est appelé à juste titre le producteur et le module de traitement de données, appelé le consommateur.
Résumé seuls les producteurs et les consommateurs, mais aussi assez sur un modèle producteur / consommateur. Ce mode aussi besoin d'avoir un tampon entre les producteurs et les consommateurs, d'intermédiaire. les données du fabricant dans la mémoire tampon, les données extraites de la mémoire tampon et le consommateur. la structure approximative figure comme suit:
À titre d'exemple envoyer une lettre à l'aide à comprendre ce que, si vous voulez envoyer une lettre ordinaire, à peu près comme suit:
La lettre écrite - données correspondant au fabricant
La lettre dans la boîte aux lettres - données équivalentes dans le fabricant tampon
Postman la lettre a été retirée de la boîte aux lettres - extraction de données tampon correspondant au consommateur
Postman prendre la lettre au bureau de poste pour faire le traitement approprié - l'équivalent du traitement des données des consommateurs
Donc, ce tampon quoi est-il? Pourquoi ne pas appeler une fonction directement aux producteurs de consommateurs, de transmettre des données directement dans le passé, et de mettre en place un superflu comme tampon il?
Les avantages de tampon suit probablement:
1: Découplage
En supposant que les producteurs et les consommateurs sont les deux classes. Si vous laissez le producteur appelant directement une méthode de consommateurs, les consommateurs devront compter sur les producteurs (c.-à-couplage). Si les consommateurs dans les changements de code futurs peuvent avoir un impact direct sur les producteurs. Si les deux se fondent sur un tampon entre les deux ne dépendant pas directement sur le degré de couplage est réduit en conséquence.
Suivant l'exemple ci-dessus, si la boîte aux lettres n'est pas utilisé (tampons), la lettre doit présenter une demande directement au facteur. Ensuite, vous devez savoir qui est le facteur. Cette dépendance entre la génération et vous et le facteur (l'équivalent du fort couplage des producteurs et des consommateurs). Si un jour les substitutions Postman, vous devez re-reconnaître le prochain facteur (modifications équivalentes conduisent à des changements dans le code producteur du consommateur). Bien que la boîte aux lettres relativement fixe, vous dépendez est un coût relativement faible (et correspondant au couplage faible entre les tampons).
2: Le traitement simultané
Producteur consommateurs appeler directement une méthode, il y a d'autres inconvénients. Étant donné que l'appel de fonction est synchrone (ou blocage d'appel), la méthode ne retourne pas avant que les consommateurs, les producteurs ont attendu là-bas. Dans le cas où le traitement des données des consommateurs est lente, les producteurs ne peuvent gaspiller injustifiée de temps.
Après avoir utilisé le modèle producteur / consommateur, les producteurs et les consommateurs peuvent être deux objet concurrent indépendant. les données du fabricant dans la mémoire tampon produit une perte de production peut aller à l'autre des données. Fondamentalement, ne comptez pas sur la vitesse de traitement du consommateur.
En fait, la plupart avaient ce modèle producteur-consommateur, est principalement utilisé pour traiter des questions de concurrence.
Exemples envoyer une lettre de la vue. S'il n'y a aucune boîte aux lettres, vous devez remettre la lettre sur position idiote dans l'intersection attendant que le facteur proche (l'équivalent du producteur d'obstruction), ou si le facteur était porte à porte pour demander, qui enverra une lettre (l'équivalent des consommateurs interrogés).
3: Cache
Si la vitesse lente lorsque la vitesse du fabricant de données, les avantages de la mémoire tampon se manifeste. Lorsque les données de fabrication rapide, les consommateurs de temps à traiter, des données non traitées peuvent être temporairement stockées dans la mémoire tampon. la vitesse de fabrication ralentissent le producteur, consommateur et disposé lentement de.
En supposant que le facteur ne peut prendre 1000 lettre. Dans le cas où un coup particulier, nous devons envoyer une lettre à plus de 1000, d'envoyer, de cartes de voeux Saint Valentin cette fois la boîte aux lettres Ce tampon est très pratique. Postman trop tard pour enlever la lettre dans la boîte aux lettres dans la mise en scène, afin de prendre la prochaine fois plus.
Par exemple:
package main
import "fmt"
// 此通道只能写，不能读。
func producer(out chan<- int) {
for i:= 0; i < 10; i++ {
out <- i*i // 将 i*i 结果写入到只写channel
}
close(out)
}
// 此通道只能读，不能写
func consumer(in <-chan int) {
for num := range in { // 从只读channel中获取数据
fmt.Println("num =", num)
}
}
func main() {
ch := make(chan int) // 创建一个双向channel
// 新建一个groutine， 模拟生产者，产生数据，写入 channel
go producer(ch) // channel传参， 传递的是引用。
// 主协程，模拟消费者，从channel读数据，打印到屏幕
consumer(ch) // 与 producer 传递的是同一个 channel
}Brève description: Tout d'abord créer un canal dans les deux sens, puis ouvrir une nouvelle goroutine, le canal à deux voies transmis à la méthode de production en tant que paramètre, et se transformer en canaux d'écriture seule. Sous Coroutine commencer le cycle, ajouter des données sur le canal d'écriture seule, ce qui est le producteur. Coroutine principal, procédé appel à la consommation directe, qui se transforme en un canal de lecture seule voie bidirectionnelle, par la lecture des données à partir de chaque cycle de la chaîne, qui est le consommateur.
Remarque: Le canal passé en paramètre est passé par référence .
Ici, nous produisons selon le modèle de consommation pour simuler ce traitement des commandes.
Dans le développement réel, les applications du modèle producteur-consommateur sont très larges, tels que: le site fournisseur d'électricité, le traitement des commandes, est un modèle producteur-consommateur typique.
Lorsque de nombreux utilisateurs cliquent sur un bouton de commande, la production de l'ordre de toutes les données dans la mémoire tampon (file d'attente), puis le consommateur sera retiré de l'expéditeur de file d'attente des systèmes de gestion d'entrepôt de données.
Par modèle producteur-consommateur, le système de commande et le système de gestion d'entrepôt est isolé, et l'utilisateur peut commander (données de production) à tout moment. Si le système de commande, appelez directement le système d'entrepôt, l'utilisateur clique sur le bouton sous les ordres d'attendre jusqu'à ce que les résultats du rendement du système d'entrepôt. Une telle vitesse sera très lente.
Après un traitement analogique de procédure dans l'ordre.
package main
import "fmt"
type OrderInfo struct { // 创建结构体类型OrderInfo，只有一个id 成员
id int
}
func producer2(out chan <- OrderInfo) { // 生成订单——生产者
for i:=0; i<10; i++ { // 循环生成10份订单
order := OrderInfo{id: i+1}
out <- order // 写入channel
}
close(out) // 写完，关闭channel
}
func consumer2(in <- chan OrderInfo) { // 处理订单——消费者
for order := range in { // 从channel 取出订单
fmt.Println("订单id为：", order.id) // 模拟处理订单
}
}
func main() {
ch := make(chan OrderInfo) // 定义一个双向 channel， 指定数据类型为OrderInfo
go producer2(ch) // 建新协程，传只写channel
consumer2(ch) // 主协程，传只读channel
}Orderinfo que des informations de commande, ici pour la simplicité ne définit qu'un seul numéro de commande d'attribut, la simulation de producteur 10 commandes, les commandes des clients sont traités produits.