Tutoriel graphique de concurrence en langage Go

Tout comme la programmation procédurale et orientée objet, un bon modèle de programmation doit avoir un noyau extrêmement simple et des extensions riches par-dessus, qui peuvent résoudre divers problèmes dans le monde réel. Toutes sortes de problèmes. Cet article prend le langage GO comme exemple pour expliquer son noyau et son extension.

Noyau en mode simultané

Ce noyau en mode simultané ne nécessite que des coroutines et des canaux. La coroutine est responsable de l'exécution du code et le canal est responsable de la transmission des événements entre les coroutines.

La programmation simultanée a toujours été un travail très difficile. Afin d'écrire un bon programme concurrent, nous devons comprendre les threads, les verrous, le sémaphore, les barrières et même la façon dont le CPU met à jour le cache, et ils ont tous un caractère étrange et sont pleins de pièges. L’auteur n’exploitera jamais moi-même ces éléments concurrents sous-jacents, sauf en cas d’absolue nécessité. Un modèle de concurrence simple ne nécessite pas ces éléments complexes de bas niveau, seuls les coroutines et les canaux suffisent.

Les coroutines sont des threads légers. En programmation procédurale, lorsque vous appelez une procédure, vous devez attendre la fin de son exécution avant de revenir. Lors de l'appel d'une coroutine, il n'est pas nécessaire d'attendre la fin de son exécution, elle reviendra immédiatement.

Les coroutines sont très légères. Le langage Go peut exécuter des centaines de milliers de coroutines en un seul processus tout en conservant des performances élevées. Pour les plates-formes ordinaires, si un processus comporte des milliers de threads, son processeur sera occupé par le changement de contexte et les performances chuteront fortement. Ce n'est pas une bonne idée de créer des threads de manière aléatoire, mais nous pouvons beaucoup utiliser les coroutines.

Channel est le canal de transmission de données entre les coroutines. Les canaux peuvent transmettre des données entre de nombreuses coroutines, qui peuvent être des valeurs ou des références. Les canaux peuvent être utilisés de deux manières.

La coroutine peut essayer de mettre des données dans le canal. Si le canal est plein, la coroutine sera suspendue jusqu'à ce que le canal puisse y mettre des données.

La coroutine peut essayer de demander des données au canal. Si le canal n'a pas de données, la coroutine sera suspendue jusqu'à ce que le canal renvoie des données.

De cette manière, le canal peut contrôler l'exécution de la coroutine lors de la transmission des données. C'est un peu comme une file d'attente événementielle et un peu comme une file d'attente bloquante. Ces deux concepts sont très simples et chaque plateforme linguistique aura des implémentations correspondantes. Il existe également des bibliothèques en Java et C qui peuvent implémenter les deux.

Tant qu'il existe des coroutines et des canaux, les problèmes de concurrence peuvent être résolus avec élégance. Il n'est pas nécessaire d'utiliser d'autres concepts liés à la concurrence. Alors comment utiliser ces deux lames tranchantes pour résoudre divers problèmes pratiques ?

Extension du mode simultané

Par rapport aux threads, les coroutines peuvent être créées en grand nombre. En ouvrant cette porte, nous pouvons étendre de nouveaux usages. Nous pouvons créer des générateurs, laisser les fonctions renvoyer des « services », laisser les boucles s'exécuter simultanément et partager des variables. Cependant, l'émergence de nouveaux usages entraîne également de nouveaux problèmes épineux : les coroutines risquent également de fuir, et une utilisation inappropriée affectera les performances. Les différents usages et problématiques seront présentés un par un ci-dessous. Le code de la démonstration est écrit en langage GO car il est concis et clair et prend en charge toutes les fonctions.

1. Générateur

Parfois, nous avons besoin d'une fonction qui peut générer des données en continu. Par exemple, cette fonction peut lire des fichiers, lire le réseau, générer des séquences à croissance automatique et générer des nombres aléatoires. Ces comportements se caractérisent par le fait que certaines variables, comme les chemins de fichiers, sont connues de la fonction. Continuez ensuite à l’appeler pour renvoyer de nouvelles données.

Ce qui suit est un exemple de génération de nombres aléatoires. Créons un générateur de nombres aléatoires qui s'exécutera simultanément.

// 函数rand_generator_1 ，返回 int
funcrand_generator_1() int {
         return rand.Int()
}
//        上面是一个函数，返回一个int。假如rand.Int()这个函数调用需要很长时间等待，那该函数的调用者也会因此而挂起。所以我们可以创建一个协程，专门执行rand.Int()。


// 函数rand_generator_2，返回通道(Channel)
funcrand_generator_2() chan int {
         // 创建通道
         out := make(chan int)
         // 创建协程
         go func() {
                  for {
                           //向通道内写入数据，如果无人读取会等待
                            out <- rand.Int()
                   }
         }()
         return out
} 
funcmain() {
         // 生成随机数作为一个服务
         rand_service_handler :=rand_generator_2()
         // 从服务中读取随机数并打印
         fmt.Printf("%d\n",<-rand_service_handler)
}

La fonction ci-dessus peut exécuter rand.Int() simultanément. Une chose à noter est que le retour d'une fonction peut être compris comme un « service ». Mais lorsque nous avons besoin d'obtenir des données aléatoires, nous pouvons y accéder à tout moment depuis ce service. Il a déjà préparé les données correspondantes pour nous, il n'y a donc pas besoin d'attendre et elles peuvent être disponibles à tout moment.

Si nous n’appelons pas ce service très fréquemment, une coroutine suffit à répondre à nos besoins. Mais que se passe-t-il si nous avons besoin d’un grand accès ? Nous pouvons utiliser la technologie de multiplexage présentée ci-dessous pour démarrer plusieurs générateurs puis les intégrer dans un grand service.

Appeler le générateur peut renvoyer un "service". Peut être utilisé dans des situations où les données sont obtenues en continu. Il a un large éventail d’utilisations : lecture de données, génération d’identifiants et même de minuteries. C'est une idée très concise, qui rend le programme concurrent.

2. Multiplexage

Le multiplexage est une technologie qui permet de traiter plusieurs files d'attente en même temps. Apache nécessite un processus pour gérer chaque connexion, ses performances de concurrence ne sont donc pas très bonnes. Nginx utilise la technologie de multiplexage pour permettre à un processus de gérer plusieurs connexions, afin que les performances de concurrence soient meilleures.

De même, dans le cas des coroutines, le multiplexage est également nécessaire, mais c'est différent. Le multiplexage peut intégrer plusieurs petits services similaires en un seul grand service.

那么让我们用多路复用技术做一个更高并发的随机数生成器吧。

// 函数rand_generator_3 ，返回通道(Channel)
         funcrand_generator_3() chan int {
         // 创建两个随机数生成器服务
         rand_generator_1 := rand_generator_2()
         rand_generator_2 := rand_generator_2()
         //创建通道
         out := make(chan int)
          //创建协程
         go func() {
                   for {
                           //读取生成器1中的数据，整合
                           out <-<-rand_generator_1
                   }
         }()
         go func() {
                   for {
                            //读取生成器2中的数据，整合
                            out <-<-rand_generator_2
                   }
         }()
         return out
}

上面是使用了多路复用技术的高并发版的随机数生成器。通过整合两个随机数生成器，这个版本的能力是刚才的两倍。虽然协程可以大量创建，但是众多协程还是会争抢输出的通道。

Go语言提供了Select关键字来解决，各家也有各家窍门。加大输出通道的缓冲大小是个通用的解决方法。

多路复用技术可以用来整合多个通道。提升性能和操作的便捷。配合其他的模式使用有很大的威力。

3、Future技术

Future是一个很有用的技术，我们常常使用Future来操作线程。我们可以在使用线程的时候，可以创建一个线程，返回Future，之后可以通过它等待结果。 但是在协程环境下的Future可以更加彻底，输入参数同样可以是Future的。

调用一个函数的时候，往往是参数已经准备好了。调用协程的时候也同样如此。但是如果我们将传入的参 数设为通道，这样我们就可以在不准备好参数的情况下调用函数。这样的设计可以提供很大的自由度和并发度。函数调用和函数参数准备这两个过程可以完全解耦。 下面举一个用该技术访问数据库的例子。

//一个查询结构体
typequery struct {
         //参数Channel
         sql chan string
         //结果Channel
         result chan string
}
//执行Query
funcexecQuery(q query) {
         //启动协程
         go func() {
                   //获取输入
                   sql := <-q.sql
                   //访问数据库，输出结果通道
                   q.result <- "get" + sql
         }()
}
funcmain() {
         //初始化Query
         q :=
                   query{make(chan string, 1),make(chan string, 1)}
         //执行Query，注意执行的时候无需准备参数
         execQuery(q)
         //准备参数
         q.sql <- "select * fromtable"
         //获取结果
         fmt.Println(<-q.result)
}

上面利用Future技术，不单让结果在Future获得，参数也是在Future获取。准备好参数后，自动执行。Future和生成器的区别在 于，Future返回一个结果，而生成器可以重复调用。还有一个值得注意的地方，就是将参数Channel和结果Channel定义在一个结构体里面作为 参数，而不是返回结果Channel。这样做可以增加聚合度，好处就是可以和多路复用技术结合起来使用。

Future技术可以和各个其他技术组合起来用。可以通过多路复用技术，监听多个结果Channel，当有结果后，自动返回。也可以和生成器组合使用，生 成器不断生产数据，Future技术逐个处理数据。Future技术自身还可以首尾相连，形成一个并发的pipe filter。这个pipe filter可以用于读写数据流，操作数据流。

Future是一个非常强大的技术手段。可以在调用的时候不关心数据是否准备好，返回值是否计算好的问题。让程序中的组件在准备好数据的时候自动跑起来。

4、并发循环

循环往往是性能上的热点。如果性能瓶颈出现在CPU上的话，那么九成可能性热点是在一个循环体内部。所以如果能让循环体并发执行，那么性能就会提高很多。

要并发循环很简单，只有在每个循环体内部启动协程。协程作为循环体可以并发执行。调用启动前设置一个计数器，每一个循环体执行完毕就在计数器上加一个元素，调用完成后通过监听计数器等待循环协程全部完成。

//建立计数器
sem :=make(chan int, N);
//FOR循环体
for i,xi:= range data {
         //建立协程
    go func (i int, xi float) {
        doSomething(i,xi);
                   //计数
        sem <- 0;
    } (i, xi);
}
// 等待循环结束
for i := 0; i < N; ++i {
 <-sem }

上面是一个并发循环例子。通过计数器来等待循环全部完成。如果结合上面提到的Future技术的话，则不必等待。可以等到真正需要的结果的地方，再去检查数据是否完成。

通过并发循环可以提供性能，利用多核，解决CPU热点。正因为协程可以大量创建，才能在循环体中如此使用，如果是使用线程的话，就需要引入线程池之类的东西，防止创建过多线程，而协程则简单的多。

5、ChainFilter技术

前面提到了Future技术首尾相连，可以形成一个并发的pipe filter。这种方式可以做很多事情，如果每个Filter都由同一个函数组成，还可以有一种简单的办法把他们连起来。

由于每个Filter协程都可以并发运行，这样的结构非常有利于多核环境。下面是一个例子，用这种模式来产生素数。

// Aconcurrent prime sieve
packagemain
// Sendthe sequence 2, 3, 4, ... to channel 'ch'.
funcGenerate(ch chan<- int) {
         for i := 2; ; i++ {
                  ch<- i // Send &#39;i&#39; to channel &#39;ch&#39;.
         }
}
// Copythe values from channel &#39;in&#39; to channel &#39;out&#39;,
//removing those divisible by &#39;prime&#39;.
funcFilter(in <-chan int, out chan<- int, prime int) {
         for {
                   i := <-in // Receive valuefrom &#39;in&#39;.
                   if i%prime != 0 {
                            out <- i // Send&#39;i&#39; to &#39;out&#39;.
                   }
         }
}
// Theprime sieve: Daisy-chain Filter processes.
funcmain() {
         ch := make(chan int) // Create a newchannel.
         go Generate(ch)      // Launch Generate goroutine.
         for i := 0; i < 10; i++ {
                   prime := <-ch
                   print(prime, "\n")
                   ch1 := make(chan int)
                   go Filter(ch, ch1, prime)
                   ch = ch1
         }
}

上面的程序创建了10个Filter，每个分别过滤一个素数，所以可以输出前10个素数。

Chain-Filter通过简单的代码创建并发的过滤器链。这种办法还有一个好处，就是每个通道只有两个协程会访问，就不会有激烈的竞争，性能会比较好

6、共享变量

协程之间的通信只能够通过通道。但是我们习惯于共享变量，而且很多时候使用共享变量能让代码更简洁。比如一个Server有两个状态开和关。其他仅仅希望获取或改变其状态，那又该如何做呢。可以将这个变量至于0通道中，并使用一个协程来维护。

下面的例子描述如何用这个方式，实现一个共享变量。

//共享变量有一个读通道和一个写通道组成
typesharded_var struct {
         reader chan int
         writer chan int
}
//共享变量维护协程
funcsharded_var_whachdog(v sharded_var) {
         go func() {
                   //初始值
                   var value int = 0
                   for {
                            //监听读写通道，完成服务
                            select {
                            case value =<-v.writer:
                            case v.reader <-value:
                            }
                   }
         }()
}
funcmain() {
         //初始化，并开始维护协程
         v := sharded_var{make(chan int),make(chan int)}
         sharded_var_whachdog(v)
         //读取初始值
         fmt.Println(<-v.reader)
         //写入一个值
         v.writer <- 1
         //读取新写入的值
         fmt.Println(<-v.reader)
}

这样，就可以在协程和通道的基础上实现一个协程安全的共享变量了。定义一个写通道，需要更新变量的时候，往里写新的值。再定义一个读通道，需要读的时候，从里面读。通过一个单独的协程来维护这两个通道。保证数据的一致性。

一般来说，协程之间不推荐使用共享变量来交互，但是按照这个办法，在一些场合，使用共享变量也是可取的。很多平台上有较为原生的共享变量支持，到底用那种 实现比较好，就见仁见智了。另外利用协程和通道，可以还实现各种常见的并发数据结构，如锁等等，就不一一赘述。

7、协程泄漏

协程和内存一样，是系统的资源。对于内存，有自动垃圾回收。但是对于协程，没有相应的回收机制。会不会若干年后，协程普及了，协程泄漏和内存泄漏一样成为 程序员永远的痛呢？

一般而言，协程执行结束后就会销毁。协程也会占用内存，如果发生协程泄漏，影响和内存泄漏一样严重。轻则拖慢程序，重则压垮机器。

C和C++都是没有自动内存回收的程序设计语言，但只要有良好的编程习惯，就能解决规避问题。对于协程是一样的，只要有好习惯就可以了。

只有两种情况会导致协程无法结束。一种情况是协程想从一个通道读数据，但无人往这个通道写入数据，或许这个通道已经被遗忘了。还有一种情况是程想往一个通道写数据，可是由于无人监听这个通道，该协程将永远无法向下执行。下面分别讨论如何避免这两种情况。

对于协程想从一个通道读数据，但无人往这个通道写入数据这种情况。解决的办法很简单，加入超时机制。对于有不确定会不会返回的情况，必须加入超时，避免出 现永久等待。

另外不一定要使用定时器才能终止协程。也可以对外暴露一个退出提醒通道。任何其他协程都可以通过该通道来提醒这个协程终止。

对于协程想往一个通道写数据，但通道阻塞无法写入这种情况。解决的办法也很简单，就是给通道加缓冲。但前提是这个通道只会接收到固定数目的写入。

比方说， 已知一个通道最多只会接收N次数据，那么就将这个通道的缓冲设置为N。那么该通道将永远不会堵塞，协程自然也不会泄漏。也可以将其缓冲设置为无限，不过这 样就要承担内存泄漏的风险了。等协程执行完毕后，这部分通道内存将会失去引用，会被自动垃圾回收掉。

funcnever_leak(ch chan int) {
         //初始化timeout，缓冲为1
         timeout := make(chan bool, 1)
         //启动timeout协程，由于缓存为1，不可能泄露
         go func() {
                   time.Sleep(1 * time.Second)
                   timeout <- true
         }()
         //监听通道，由于设有超时，不可能泄露
         select {
         case <-ch:
                   // a read from ch hasoccurred
         case <-timeout:
                   // the read from ch has timedout
         }
}

上面是个避免泄漏例子。使用超时避免读堵塞，使用缓冲避免写堵塞。

和内存里面的对象一样，对于长期存在的协程，我们不用担心泄漏问题。一是长期存在，二是数量较少。要警惕的只有那些被临时创建的协程，这些协程数量大且生 命周期短，往往是在循环中创建的，要应用前面提到的办法，避免泄漏发生。协程也是把双刃剑，如果出问题，不但没能提高程序性能，反而会让程序崩溃。但就像 内存一样，同样有泄漏的风险，但越用越溜了。

并发模式之实现

在并发编程大行其道的今天，对协程和通道的支持成为各个平台比不可少的一部分。虽然各家有各家的叫法，但都能满足协程的基本要求—并发执行和可大量创建。笔者对他们的实现方式总结了一下。

下面列举一些已经支持协程的常见的语言和平台。

GoLang 和Scala作为最新的语言，一出生就有完善的基于协程并发功能。Erlang最为老资格的并发编程语言，返老还童。其他二线语言则几乎全部在新的版本中加入了协程。

Il est surprenant que C/C++ et Java, les trois plates-formes les plus répandues au monde, ne fournissent pas de support natif au niveau du langage pour les coroutines. Ils portent tous le poids d’une lourde histoire qui ne peut ni ne doit être modifiée. Mais ils ont d’autres façons d’utiliser les coroutines.

Il existe de nombreuses façons d'implémenter des coroutines sur la plateforme Java :

· Modifier la machine virtuelle : patcher la JVM pour implémenter les coroutines. Cette implémentation est efficace, mais elle perd les avantages du cross-. plateforme

· Modifier le bytecode : améliorez le bytecode une fois la compilation terminée ou utilisez un nouveau langage JVM. Augmente légèrement la difficulté de compilation.

· Utiliser JNI : utilisez JNI dans le package Jar, qui est facile à utiliser, mais ne peut pas être multiplateforme.

· Utilisez des threads pour simuler des coroutines : rendez les coroutines plus lourdes et comptez entièrement sur l'implémentation des threads JVM.

Parmi eux, la méthode de modification du bytecode est la plus courante. Parce que cette méthode de mise en œuvre peut équilibrer performances et portabilité. Scale, le langage JVM le plus représentatif, peut bien prendre en charge la simultanéité des coroutines. La populaire bibliothèque de classes de modèles Java Actor akka est également une coroutine implémentée en modifiant le bytecode.

Pour le langage C, les coroutines sont les mêmes que les threads. Cela peut être accompli en utilisant une variété d'appels système. En tant que concept relativement avancé, les coroutines ont trop de méthodes d’implémentation, nous n’en discuterons donc pas ici. Les implémentations les plus courantes incluent libpcl, coro, lthread, etc.

Pour C++, il existe une implémentation Boost, ainsi que quelques autres bibliothèques open source. Il existe également un langage appelé μC++, qui fournit des extensions de concurrence basées sur C++.

On peut constater que ce modèle de programmation a été largement pris en charge sur de nombreuses plateformes linguistiques et n'est plus une niche. Si vous souhaitez l'utiliser, vous pouvez l'ajouter à votre boîte à outils à tout moment.

Pour plus d'articles sur le langage Go, veuillez prêter attention à la colonne Tutoriel sur le langage Go.

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!