Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi]

Apakah rupa pelbagai mod konkurensi dalam golang? Artikel berikut akan menunjukkan Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] concurrency untuk anda melalui 20 gambar animasi Saya harap ia akan membantu semua orang!

Jika anda lebih suka mempelajari artikel ini melalui video, sila klik untuk menonton ceramah saya di Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]pherCon www.youtube.com/ tonton? v=KyuFeiG3Y6...

Salah satu ciri yang paling berkuasa dalam bahasa Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] ialah penyelarasan terbina dalam yang dilaksanakan berdasarkan kertas ini CSP Tony Hoare ialah direka dengan mengambil kira ini Concurrency dan membolehkan kami membina saluran paip concurrency yang kompleks. Pernahkah anda terfikir bagaimana rupa pelbagai mod konkurensi?

Anda pasti pernah memikirkannya. Selalunya kita memikirkan masalah melalui imaginasi Jika saya bertanya kepada anda tentang "nombor dari 1 hingga 100", satu siri gambar secara tidak sedar akan muncul dalam fikiran anda. Sebagai contoh, saya akan membayangkannya sebagai garis lurus bermula dari saya, pergi dari nombor 1 hingga 20 dan kemudian membelok ke kanan 90 darjah hingga ke 1000. Saya masih ingat semasa saya masih kecil, di tadika kami, terdapat banyak nombor yang ditulis di dinding di dalam bilik jubah, dan nombor 20 kebetulan berada di sudut. Anda mungkin mempunyai gambar nombor anda sendiri. Satu lagi contoh biasa ialah gambaran visual musim tahun ini - sesetengahnya membayangkannya sebagai kotak, yang lain sebagai bulatan.

Dalam apa jua keadaan, saya mahu menggunakan Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dan WebGL untuk menunjukkan kepada anda percubaan saya untuk memvisualisasikan corak konkurensi biasa Ini lebih kurang mewakili pemahaman saya tentang program serentak. Ia akan menjadi sangat menarik untuk mendengar bagaimana saya berbeza daripada gambar yang anda ada di kepala anda. Saya ingin tahu secara khusus bagaimana Rob Pike atau Sameer Ajmani menggambarkan kesesuaian dalam kepala mereka. [Cadangan berkaitan: Pergi tutorial video]

Jadi, mari kita mulakan topik kita hari ini dengan contoh "Hello, Concurrent World" yang sangat asas.

Helo, Dunia serentak

Kodnya mudah - saluran tunggal, goroutine tunggal, tulis tunggal, Bacaan tunggal .

package main

func main() {
    // 创建一个int类型的通道
    ch := make(chan int)

    // 开启一个匿名 goroutine
    go func() {
        // 向通道发送数字42
        ch <p><a href="https://divan.dev/demos/hello/" target="_blank">Pergi ke animasi WebGL interaktif </a> <img src="https://img.php.cn/upload/article/000/000/024/03104ecc960e1992d7b04ec4cd79a77f-0.gif" alt="Hello, World"></p><p>Garis biru mewakili goroutine yang berjalan dari semasa ke semasa garis biru nipis digunakan untuk menandakan permulaan dan akhir goroutine dan menunjukkan hubungan ibu bapa-anak Akhir sekali, garis merah mewakili tindakan hantar/terima Walaupun ini adalah dua tindakan yang berasingan, saya masih cuba menggunakan "hantar daripada Animasi A hingga B" Ekspresikannya sebagai tindakan. "#19" dalam nama goroutine ialah ID dalaman sebenar goroutine. Untuk kaedah mendapatkannya, rujuk artikel "ID Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]routine" Scott Mansfield. </p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">Pemasa</span></strong>
</h3><p> Sebenarnya, anda boleh membina pemasa mudah dengan mencipta saluran , mulakan goroutine untuk menulis data ke saluran selepas selang masa yang ditentukan, dan kemudian kembalikan saluran itu kepada pemanggil. Jadi fungsi panggilan akan menyekat apabila membaca saluran sehingga selang masa yang ditetapkan sebelum ini telah berlalu. Seterusnya kita memanggil pemasa 24 kali dan cuba memvisualisasikan proses panggilan. </p><pre class="brush:php;toolbar:false">package main

import "time"

func timer(d time.Duration) <p><a href="https://divan.dev/demos/timers/" target="_blank">Pergi ke animasi WebGL interaktif </a> <img src="https://img.php.cn/upload/article/000/000/024/6e2b2d910982ba58209c1c53cd9c7f6d-1.gif" alt="Recurrent Timers"></p><p>Bagus, kan? </p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">Ping-pong</span></strong>
</h3><p>Concurrency concurrency ini diambil daripada pekerja Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]ogle Sameer Ajmani “<a href="https://talks.golang.org/2013/advconc.slide#1" target="_blank" textvalue="Advanced Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] Concurrency Patterns">Advanced Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] Concurrency Corak </a>” Ucapan. Sudah tentu, corak ini tidak begitu maju, tetapi ia mungkin kelihatan baharu dan menarik bagi mereka yang hanya biasa dengan mekanik serentak Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]. </p><p>Di sini kita menggunakan saluran untuk mewakili meja pingpong Pembolehubah integer mewakili bola, dan kemudian dua goroutin digunakan untuk mewakili pemain itu mensimulasikan tindakan memukul dengan meningkatkan nilai pembolehubah integer (klik kaunter). </p><pre class="brush:php;toolbar:false">package main

import "time"

func main() {
    var Ball int
    table := make(chan int)
    go player(table)
    go player(table)

    table <p><a href="https://divan.dev/demos/pingpong/" target="_blank" textvalue="转到交互式 WebGL 动画">Pergi ke animasi WebGL interaktif</a> <img src="https://img.php.cn/upload/article/000/000/024/6e2b2d910982ba58209c1c53cd9c7f6d-2.gif" alt="Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]"></p><p>Di sini saya cadangkan anda klik pada <a href="https://divan.dev/demos/pingpong/" target="_blank">pautan</a> untuk memasuki animasi WebGL Anda boleh memperlahankan atau mempercepatkan animasi dan melihatnya dari sudut yang berbeza. </p><p>Sekarang, mari tambah tiga pemain dan lihat. </p><pre class="brush:php;toolbar:false">    go player(table)
    go player(table)
    go player(table)

转到交互式 WebGL 动画 我们可以看到每个玩家都按照次序轮流操作，你可能会想为什么会这样。为什么多个玩家（goroutine）会按照严格的顺序接到“球”呢。

答案是 Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] 运行时环境维护了一个 接收者 FIFO 队列 (存储需要从某一通道上接收数据的goroutine)，在我们的例子里，每个玩家在刚发出球后就做好了接球准备。我们来看一下更复杂的情况，加入100个玩家。

for i := 0; i <p><a href="https://divan.dev/demos/pingpong100/" target="_blank">转到交互式 WebGL 动画</a> <img src="https://img.php.cn/upload/article/000/000/024/f022e6361217c7f4c90e16d8d0885f99-4.gif" alt="Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] 100"> </p><p>先进先出顺序很明显了，是吧? 我们可以创建一百万个goroutine，因为它们很轻量，但是对于实现我们的目的来说没有必要。我们来想想其他可以玩的。 例如, 常见的消息传递模式。</p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">Fan-In</span></strong>
</h3><p>并发世界中流行的模式之一是所谓的 <em>fan-in</em> 模式。这与 <em>fan-out</em> 模式相反，稍后我们将介绍。简而言之，fan-in 是一项功能，可以从多个输入中读取数据并将其全部多路复用到单个通道中。</p><p>举例来说：</p><pre class="brush:php;toolbar:false">package main

import (
    "fmt"
    "time"
)

func producer(ch chan int, d time.Duration) {
    var i int
    for {
        ch <p><a href="https://divan.dev/demos/fanin/" target="_blank">Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] to interactive WebGL animation</a> <img src="https://img.php.cn/upload/article/000/000/024/f022e6361217c7f4c90e16d8d0885f99-5.gif" alt="Fan-In Pattern"></p><p>如我们所见，第一个 <em>producer</em> 每100毫秒生成一次值，第二个每250毫秒生成一次值，但是 <em>reader</em> 会立即从这两个生产者那里接受值。实际上，多路复用发生在 <em>main</em> 的range循环中。</p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">Workers</span></strong>
</h3><p>与 <em>fan-in</em> 相反的模式是 <em>fan-out</em> 或者<em>worker</em> 模式。多个 goroutine 可以从单个通道读取，从而在CPU内核之间分配大量的工作量，因此是 <em>worker</em> 的名称。在Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]中，此模式易于实现-只需以通道为参数启动多个goroutine，然后将值发送至该通道-Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]运行时会自动地进行分配和复用 :)</p><pre class="brush:php;toolbar:false">package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(tasksCh <p><img src="https://img.php.cn/upload/article/000/000/024/bc82f8929dc05185db5d2b4542d2ca73-6.gif" alt="Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]"></p><p>这里值得一提的是：并行性。如您所见，所有goroutine并行’运行‘，等待通道给予它们’工作‘。鉴于上面的动画，很容易发现goroutine几乎立即接连地收到它们的工作。不幸的是，该动画在goroutine确实在处理工作还是仅仅是在等待输入的地方没有用颜色显示出来，但是此动画是在GOMAXPROCS=4的情况下录制的，因此只有4个goroutine有效地并行运行。我们将很快讨论这个主题。</p><p>现在，让我们做一些更复杂的事情，并启动一些有自己workers（subworkers）的workers。</p><pre class="brush:php;toolbar:false">package main

import (
    "fmt"
    "sync"
    "time"
)

const (
    WORKERS    = 5
    SUBWORKERS = 3
    TASKS      = 20
    SUBTASKS   = 10
)

func subworker(subtasks chan int) {
    for {
        task, ok := <p><a href="https://divan.dev/demos/workers2/" target="_blank">Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] to interactive WebGL animation</a> <img src="https://img.php.cn/upload/article/000/000/024/bc82f8929dc05185db5d2b4542d2ca73-7.gif" alt="Workers of workers"> 很好。当然，我们可以将worker和subworker的数量设置为更高的值，但是我试图使动画清晰易懂。</p><p>更酷的 fan-out 模式确实存在，例如动态数量的worker/subworker，通过通道发送通道，但是 fan-out 的想法现在应该很清楚了。</p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">服务器</span></strong>
</h3><p>下一个常见的模式类似于扇出，但是会在很短的时间内生成goroutine，只是为了完成某些任务。它通常用于实现服务器-创建侦听器，循环运行accept()并为每个接受的连接启动goroutine。它非常具有表现力，可以实现尽可能简单的服务器处理程序。看一个简单的例子：</p><pre class="brush:php;toolbar:false">package main

import "net"

func handler(c net.Conn) {
    c.Write([]byte("ok"))
    c.Close()
}

func main() {
    l, err := net.Listen("tcp", ":5000")
    if err != nil {
        panic(err)
    }
    for {
        c, err := l.Accept()
        if err != nil {
            continue
        }
        go handler(c)
    }
}

Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] to 交互式WebGL动画  

这不是很有趣-似乎并发方面没有发生任何事情。当然，在引擎盖下有很多复杂性，这是我们特意隐藏的。 “简单性很复杂”.

但是，让我们回到并发性并向我们的服务器添加一些交互。假设每个处理程序都希望异步写入记录器。在我们的示例中，记录器本身是一个单独的goroutine，它可以完成此任务。

package main

import (
    "fmt"
    "net"
    "time"
)

func handler(c net.Conn, ch chan string) {
    ch <p><a href="https://divan.dev/demos/servers2/" target="_blank">Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] to 交互式WebGL动画</a> <img src="https://img.php.cn/upload/article/000/000/024/dfdd69afd5511ae20942d0af033a1db2-9.gif" alt="Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] 2"> </p><p>不是吗？但是很容易看到，如果请求数量增加并且日志记录操作花费一些时间(例如，准备和编码数据)，我们的* logger * goroutine很快就会成为瓶颈。我们可以使用一个已知的扇出模式。我们开始做吧。</p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">服务器+工作者</span></strong>
</h3><p>带工作程序的服务器示例是记录器的高级版本。它不仅可以完成一些工作，而且还可以通过* results *通道将其工作结果发送回池中。没什么大不了的，但是它将我们的记录器示例扩展到了更实际的示例。</p><p>让我们看一下代码和动画：</p><pre class="brush:php;toolbar:false">package main

import (
    "net"
    "time"
)

func handler(c net.Conn, ch chan string) {
    addr := c.RemoteAddr().String()
    ch <p><a href="https://divan.dev/demos/servers3/" target="_blank">Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] to 交互式WebGL动画</a> <img src="https://img.php.cn/upload/article/000/000/024/d04fb172e580bf3c4b0bca0edac0a234-10.gif" alt="Server + Worker"> 我们在4个goroutine之间分配了工作，有效地提高了记录器的吞吐量，但是从此动画中，我们可以看到记录器仍然可能是问题的根源。成千上万的连接在分配之前会汇聚在一个通道中，这可能导致记录器再次成为瓶颈。但是，当然，它会在更高的负载下发生。</p><h3>
<span class="header-link octicon octicon-link"></span><strong><span style="font-size: 18px;">并发素筛(素筛指素数筛法)</span></strong>
</h3><p>足够的扇入/扇出乐趣。让我们看看更复杂的并发算法。我最喜欢的例子之一是Concurrent Prime Sieve，可以在[<a href="https://talks.golang.org/2012/concurrency.slide" target="_blank">Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] Concurrency Patterns</a>]对话中找到。素数筛，或<a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes" target="_blank">[Eratosthenes筛)</a>是一种古老的算法，用于查找达到给定限制的素数。它通过按顺序消除所有质数的倍数来工作。天真的算法并不是真正有效的算法，尤其是在多核计算机上。</p><p>该算法的并发变体使用goroutine过滤数字-每个发现的素数一个goroutine，以及用于将数字从生成器发送到过滤器的通道。找到质数后，它将通过通道发送到* main *以进行输出。当然，该算法也不是很有效，特别是如果您想找到大质数并寻找最低的Big O复杂度，但是我发现它非常优雅。</p><pre class="brush:php;toolbar:false">// 并发的主筛
package main

import "fmt"

// 将序列2、3、4，...发送到频道“ ch”。
func Generate(ch chan<- int) {
    for i := 2; ; i++ {
        ch <- i // Send &#39;i&#39; to channel &#39;ch&#39;.
    }
}

//将值从通道“ in”复制到通道“ out”，
//删除可被“素数”整除的那些。
func Filter(in <-chan int, out chan<- int, prime int) {
    for {
        i := <-in // Receive value from &#39;in&#39;.
        if i%prime != 0 {
            out <- i // Send &#39;i&#39; to &#39;out&#39;.
        }
    }
}

//主筛：菊花链过滤器过程。
func main() {
    ch := make(chan int) // Create a new channel.
    go Generate(ch)      // Launch Generate goroutine.
    for i := 0; i < 10; i++ {
        prime := <-ch
        fmt.Println(prime)
        ch1 := make(chan int)
        go Filter(ch, ch1, prime)
        ch = ch1
    }
}

转到交互式WebGL动画

，请以交互模式随意播放此动画。我喜欢它的说明性-它确实可以帮助您更好地理解该算法。 * generate * goroutine发出从2开始的每个整数，每个新的goroutine仅过滤特定的质数倍数-2、3、5、7 …，将第一个找到的质数发送给* main *。如果旋转它从顶部看，您会看到从goroutine发送到main的所有数字都是质数。漂亮的算法，尤其是在3D中。

GOMAXPROCS（调整并发的运行性能）

现在，让我们回到我们的工作人员示例。还记得我告诉过它以GOMAXPROCS = 4运行吗？那是因为所有这些动画都不是艺术品，它们是真实程序的真实痕迹。

让我们回顾一下GOMAXPROCS是什么。

GOMAXPROCS设置可以同时执行的最大CPU数量。

当然，CPU是指逻辑CPU。我修改了一些示例，以使他们真正地工作(而不仅仅是睡觉)并使用实际的CPU时间。然后，我运行了代码，没有进行任何修改，只是设置了不同的GOMAXPROCS值。 Linux机顶盒有2个CPU，每个CPU具有12个内核，因此有24个内核。

因此，第一次运行演示了该程序在1个内核上运行，而第二次-使用了所有24个内核的功能。

WebGL动画-1| WebGL动画-24GOMAXPROCS1

Kelajuan masa dalam animasi ini berbeza (saya mahu semua animasi muat dalam masa/ketinggian yang sama), jadi perbezaannya adalah ketara. Apabila GOMAXPROCS = 1, pekerja seterusnya hanya boleh memulakan kerja sebenar selepas yang sebelumnya selesai. Dalam kes GOMAXPROCS = 24, kelajuan adalah sangat besar, manakala overhed pemultipleksan diabaikan.

Walau bagaimanapun, adalah penting untuk memahami bahawa peningkatan GOMAXPROCS tidak selalunya meningkatkan prestasi dan dalam beberapa kes sebenarnya boleh memburukkan lagi keadaan.

Kebocoran Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]routine

Apakah yang boleh kita buktikan daripada masa konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi]? Satu perkara yang terlintas di fikiran ialah kebocoran goroutine. Contohnya, jika anda memulakan goroutine tetapi ia di luar skop , kebocoran mungkin berlaku. Atau anda hanya terlupa untuk menambah syarat akhir dan sebaliknya menjalankan gelung untuk{}.

Kali pertama saya mengalami kebocoran goroutine dalam kod saya, imej menakutkan muncul di fikiran saya dan pada hujung minggu berikutnya saya menulis expvarmon. Kini saya boleh menggambarkan imej yang menakutkan ini menggunakan WebGL.

Lihat:

Saya berasa sakit hati melihat ini :) Semua talian ini adalah pembaziran sumber dan merupakan sebahagian daripada program anda Bom masa .

Parallelisme bukan Concurrency

Perkara terakhir yang saya ingin nyatakan ialah perbezaan antara paralelisme dan perbezaan concurrency. Topik ini merangkumi banyak dan Rob Pike memberikan ceramah yang menarik mengenai topik ini. Benar-benar salah satu video yang #mesti tonton.

Ringkasnya,

Paralelisme hanyalah menjalankan perkara secara selari.

Concurrency ialah cara untuk menstruktur program.

Oleh itu, program serentak mungkin selari atau tidak, dan konsep ini agak ortogon. Kami telah melihat ini apabila menunjukkan kesan tetapan GOMAXPROCS.

Saya boleh mengulangi semua artikel dan ceramah yang dipautkan ini, tetapi sekeping gambar bercakap seribu perkataan. Apa yang boleh saya lakukan di sini ialah menggambarkan perbezaannya. Jadi ia selari. Banyak perkara berjalan selari.

Pergi ke animasi WebGL interaktif

Ini juga selari:

Pergi ke animasi WebGL interaktif

Tetapi ini serentak:

Dan yang ini:

Ini juga serentak:

Bagaimana ia dibuat

Untuk mencipta animasi ini, saya menulis dua program: pustaka gotracer dan gothree.js. Mula-mula, gotracer melakukan perkara berikut:

• Menghuraikan pepohon AST (Pokok Sintaks Abstrak) program Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dan memasukkan arahan khas dengan output pada acara berkaitan konkurensi - mulakan/ Hentikan goroutine, cipta saluran , hantar/terima ke/dari saluran.
• Jalankan program yang dijana
• analisis output khas ini dan hasilkan JSON dengan perihalan peristiwa dan cap masa.

Contoh JSON yang dijana:

Seterusnya, gothree.js menggunakan kuasa pustaka Three.js yang menakjubkan untuk melukis menggunakan garisan 3D WebGL dan objek. Saya melakukan beberapa pembalut yang sangat kecil untuk menjadikannya dimuatkan ke dalam satu halaman html - itu sahaja.

Namun, kaedah ini sangat terhad. Saya terpaksa memilih contoh saya dengan tepat, menamakan semula saluran dan goroutine, untuk menjadikan kod yang lebih atau kurang kompleks menghasilkan jejak yang betul. Dengan pendekatan ini, tidak ada cara mudah untuk mengaitkan saluran antara gorouti jika mereka mempunyai nama yang berbeza. Apatah lagi saluran yang dihantar melalui saluran jenis chan. Terdapat juga isu besar dengan pemasaan - mengeluarkan ke stdout boleh mengambil lebih banyak masa daripada menghantar nilai, jadi dalam beberapa kes saya perlu meletakkan masa. Tidur (beberapa milisaat) untuk mendapatkan animasi yang betul.

Pada asasnya, inilah sebabnya saya belum mempunyai kod sumber terbuka. Saya bermain dengan Penjejak Pelaksanaan Dmitry Vyukov dan nampaknya memberikan butiran acara itu, tetapi tidak termasuk menghantar maklumat yang layak. Mungkin ada cara yang lebih baik untuk mencapai matlamat yang diingini. Jika anda mempunyai idea, hantarkan saya talian di twitter atau letakkan saya baris dalam komen. Alangkah baiknya jika alat dua minggu ini boleh dikembangkan menjadi alat penyahpepijat/penjejakan sebenar untuk sebarang program Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi].

Saya juga ingin melihat lebih banyak algoritma dan corak serentak yang menarik yang tidak disenaraikan di sini. Jangan ragu untuk menulis satu dalam komen.

Selamat pengekodan!

UPD: Alat ini tersedia di github.com/pan/gotrace dan dijana menggunakan Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] Execution Tracer dan trek masa jalan yang ditampal.

Selain itu, saya terbuka kepada pekerjaan baharu, jadi jika syarikat/pasukan anda berminat dengan saya, menghadapi masalah sukar untuk diselesaikan menggunakan Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi] dalam satu artikel [20 demonstrasi gambar animasi], saya boleh bekerja dari jauh (atau anda berada di Barcelona) dan sedang mengambil pekerja, sila beritahu saya :)

Alamat asal bahasa Inggeris: https://divan.dev/posts/go_concurrency_visualize/

Untuk lebih banyak pengetahuan berkaitan pengaturcaraan, sila lawati: Video Pengaturcaraan ! !

Atas ialah kandungan terperinci Penjelasan terperinci tentang konkurensi dalam Go dalam satu artikel [20 demonstrasi gambar animasi]. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!