Grafisches Tutorial zur Parallelität in der Go-Sprache

Genau wie die prozedurale Programmierung und die objektorientierte Programmierung muss ein gutes Programmiermodell einen extrem einfachen Kern und umfangreiche Erweiterungen darauf haben, die verschiedene Probleme in der realen Welt lösen können. Alle möglichen Probleme. In diesem Artikel wird die GO-Sprache als Beispiel verwendet, um ihren Kern und ihre Erweiterung zu erläutern.

Kernel im Parallelmodus

Dieser Kernel im Parallelmodus erfordert nur Coroutinen und Kanäle. Die Coroutine ist für die Ausführung von Code verantwortlich und der Kanal ist für die Übermittlung von Ereignissen zwischen Coroutinen verantwortlich.

Konkurrenzprogrammierung war schon immer eine sehr schwierige Aufgabe. Um ein gutes gleichzeitiges Programm zu schreiben, müssen wir Threads, Sperren, Semaphore, Barrieren und sogar die Art und Weise verstehen, wie die CPU den Cache aktualisiert, und sie alle haben seltsame Gemüter und sind voller Fallen. Der Autor wird diese zugrunde liegenden gleichzeitigen Elemente niemals selbst betreiben, es sei denn, dies ist unbedingt erforderlich. Für ein prägnantes Parallelitätsmuster sind diese komplexen Low-Level-Elemente nicht erforderlich, lediglich Coroutinen und Kanäle reichen aus.

Coroutinen sind leichte Threads. Wenn Sie in der prozeduralen Programmierung eine Prozedur aufrufen, müssen Sie warten, bis die Ausführung abgeschlossen ist, bevor Sie zurückkehren. Wenn Sie eine Coroutine aufrufen, müssen Sie nicht warten, bis die Ausführung abgeschlossen ist. Sie kehrt sofort zurück.

Coroutinen sind sehr leichtgewichtig und können Hunderttausende von Coroutinen in einem Prozess ausführen und dennoch eine hohe Leistung aufrechterhalten. Wenn ein Prozess auf normalen Plattformen Tausende von Threads hat, ist seine CPU mit Kontextwechseln beschäftigt und die Leistung nimmt stark ab. Es ist keine gute Idee, Threads zufällig zu erstellen, aber wir können häufig Coroutinen verwenden.

Kanal ist der Datenübertragungskanal zwischen Coroutinen. Kanäle können Daten zwischen vielen Coroutinen übergeben, bei denen es sich um Werte oder Referenzen handeln kann. Kanäle können auf zwei Arten verwendet werden.

Die Coroutine kann versuchen, Daten in den Kanal zu übertragen. Wenn der Kanal voll ist, wird die Coroutine angehalten, bis der Kanal Daten dafür bereitstellen kann.

Die Coroutine kann versuchen, Daten vom Kanal anzufordern. Wenn der Kanal keine Daten hat, wird die Coroutine angehalten, bis der Kanal Daten zurückgibt.

Auf diese Weise kann der Kanal die Ausführung der Coroutine während der Datenübertragung steuern. Es ist ein bisschen wie ereignisgesteuert und ein bisschen wie eine blockierende Warteschlange. Diese beiden Konzepte sind sehr einfach und jede Sprachplattform verfügt über entsprechende Implementierungen. Es gibt auch Bibliotheken in Java und C, die beides implementieren können.

Solange es Coroutinen und Kanäle gibt, können Parallelitätsprobleme elegant gelöst werden. Es besteht keine Notwendigkeit, andere Konzepte im Zusammenhang mit der Parallelität zu verwenden. Wie kann man also mit diesen beiden scharfen Klingen verschiedene praktische Probleme lösen?

Erweiterung des Parallelitätsmodus

Im Vergleich zu Threads können Coroutinen in großer Zahl erstellt werden. Indem wir diese Tür öffnen, können wir neue Verwendungsmöglichkeiten erweitern. Wir können Generatoren erstellen, Funktionen „Dienste“ zurückgeben, Schleifen gleichzeitig ausführen lassen und Variablen gemeinsam nutzen. Das Aufkommen neuer Verwendungszwecke bringt jedoch auch neue heikle Probleme mit sich. Auch Coroutinen werden auslaufen und eine unsachgemäße Verwendung beeinträchtigt die Leistung. Im Folgenden werden die verschiedenen Verwendungszwecke und Probleme einzeln vorgestellt. Der Code für die Demonstration ist in der Sprache GO geschrieben, da er prägnant und klar ist und alle Funktionen unterstützt.

1. Generator

Manchmal benötigen wir eine Funktion, die kontinuierlich Daten generieren kann. Diese Funktion kann beispielsweise Dateien lesen, das Netzwerk lesen, selbstwachsende Sequenzen generieren und Zufallszahlen generieren. Diese Verhaltensweisen zeichnen sich dadurch aus, dass einige Variablen der Funktion bekannt sind, beispielsweise Dateipfade. Rufen Sie es dann weiter auf, um neue Daten zurückzugeben.

Das Folgende ist ein Beispiel für die Generierung von Zufallszahlen. Lassen Sie uns einen Zufallszahlengenerator erstellen, der gleichzeitig ausgeführt wird.

// 函数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)
}

Die obige Funktion kann rand.Int() gleichzeitig ausführen. Es ist erwähnenswert, dass die Rückgabe einer Funktion als „Dienst“ verstanden werden kann. Wenn wir jedoch zufällige Daten benötigen, können wir jederzeit über diesen Dienst darauf zugreifen. Die entsprechenden Daten sind bereits für uns vorbereitet, sodass keine Wartezeit besteht und sie jederzeit verfügbar sind.

Wenn wir diesen Dienst nicht sehr häufig aufrufen, reicht eine Coroutine aus, um unsere Anforderungen zu erfüllen. Aber was ist, wenn wir viel Zugang benötigen? Mit der nachfolgend vorgestellten Multiplexing-Technologie können wir mehrere Generatoren starten und diese dann in einen großen Dienst integrieren.

Ein Aufruf des Generators kann einen „Dienst“ zurückgeben. Kann in Situationen verwendet werden, in denen kontinuierlich Daten erfasst werden. Es verfügt über ein breites Anwendungsspektrum, das Lesen von Daten, das Generieren von IDs und sogar Timer. Dies ist eine sehr prägnante Idee, die das Programm gleichzeitig macht.

2. Multiplexing

Multiplexing ist eine Technologie, die die gleichzeitige Verarbeitung mehrerer Warteschlangen ermöglicht. Apache benötigt einen Prozess, um jede Verbindung zu verarbeiten, daher ist seine Parallelitätsleistung nicht sehr gut. Nginx verwendet Multiplexing-Technologie, damit ein Prozess mehrere Verbindungen verarbeiten kann, sodass die Parallelitätsleistung besser ist.

In ähnlicher Weise ist auch bei Coroutinen Multiplexing erforderlich, aber es ist anders. Durch Multiplexing können mehrere ähnliche kleine Dienste in einen großen Dienst integriert werden.

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

// 函数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最为老资格的并发编程语言，返老还童。其他二线语言则几乎全部在新的版本中加入了协程。

Es ist überraschend, dass C/C++ und Java, die drei Mainstream-Plattformen der Welt, keine native Unterstützung für Coroutinen auf Sprachebene bieten. Sie alle sind mit einer schweren Geschichte belastet, die nicht geändert werden kann und muss. Aber sie haben andere Möglichkeiten, Coroutinen zu verwenden.

Es gibt viele Möglichkeiten, Coroutinen auf der Java-Plattform zu implementieren:

· Ändern Sie die virtuelle Maschine: Patchen Sie die JVM, um Coroutinen zu implementieren, aber sie verliert die Vorteile von Cross-. Plattform

· Bytecode ändern: Erweitern Sie den Bytecode nach Abschluss der Kompilierung oder verwenden Sie eine neue JVM-Sprache. Erhöht den Schwierigkeitsgrad der Kompilierung leicht.

· JNI verwenden: Verwenden Sie JNI im Jar-Paket, das einfach zu verwenden ist, aber nicht plattformübergreifend sein kann.

· Verwenden Sie Threads, um Coroutinen zu simulieren: Machen Sie Coroutinen zu einem Schwergewicht und verlassen Sie sich vollständig auf die JVM-Thread-Implementierung.

Unter diesen ist die Methode zum Ändern des Bytecodes häufiger anzutreffen. Weil diese Implementierungsmethode Leistung und Portabilität in Einklang bringen kann. Scale, die repräsentativste JVM-Sprache, kann die Parallelität von Coroutinen gut unterstützen. Die beliebte Java Actor-Modellklassenbibliothek akka ist ebenfalls eine Coroutine, die durch Modifizieren des Bytecodes implementiert wird.

Für die Sprache C sind Coroutinen dasselbe wie Threads. Dies kann durch verschiedene Systemaufrufe erreicht werden. Als relativ fortgeschrittenes Konzept verfügen Coroutinen über zu viele Implementierungsmethoden, daher werden wir sie hier nicht diskutieren. Zu den Mainstream-Implementierungen gehören libpcl, coro, lthread usw.

Für C++ gibt es eine Boost-Implementierung sowie einige andere Open-Source-Bibliotheken. Es gibt auch eine Sprache namens μC++, die auf C++ basierende Parallelitätserweiterungen bereitstellt.

Es ist ersichtlich, dass dieses Programmiermodell auf vielen Sprachplattformen weithin unterstützt wird und keine Nische mehr ist. Wenn Sie es nutzen möchten, können Sie es jederzeit zu Ihrer Toolbox hinzufügen.

Weitere Artikel zum Thema Go-Sprache finden Sie in der Spalte Go-Sprach-Tutorial.

Das obige ist der detaillierte Inhalt vonGrafisches Tutorial zur Parallelität in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!