Penerokaan perbezaan antara concurrency dan paralelisme dalam bahasa Go

Meneroka perbezaan antara concurrency dan parallelism dalam bahasa Go

Dalam bahasa Go, anda sering mendengar konsep concurrency dan parallelism. Walaupun kedua-dua perkataan ini sering digunakan secara bergantian, ia sebenarnya mempunyai makna yang berbeza. Artikel ini akan meneroka perbezaan antara concurrency dan paralelisme dalam bahasa Go dan menggunakan contoh kod khusus untuk menggambarkan perbezaan antara mereka.

Pertama, mari kita lihat definisi konkurensi dan selari:

• Konkurensi (concurrency) merujuk kepada memproses berbilang tugasan dalam tempoh masa yang sama, tetapi secara bergilir-gilir responsif dan kecekapan sistem.
• Paralelisme merujuk kepada memproses berbilang tugas pada masa yang sama Tugas-tugas ini benar-benar dijalankan pada berbilang pemproses pada masa yang sama untuk mencapai kelajuan pemprosesan yang lebih pantas.

Dalam bahasa Go, keselarasan dicapai melalui goroutine. Goroutine ialah utas ringan dalam bahasa Go Ia dijadualkan oleh sistem masa jalan bahasa Go dan boleh mencapai pelaksanaan serentak pada satu utas. Anda boleh mencipta goroutine dengan kata kunci go supaya fungsi tersebut dilaksanakan dalam goroutine bebas. go可以创建一个goroutine，使函数在一个独立的goroutine中执行。

让我们通过一个简单的示例来说明并发和并行的区别：

package main

import (
    "fmt"
    "runtime"
    "time"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Task %d: %d
", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 设置使用的最大CPU核心数

    go task(1)
    go task(2)

    time.Sleep(time.Second)
}

在上面的代码中，我们定义了两个函数task，每个函数打印5次任务的信息，并在每次打印后暂停100毫秒。在main函数中，我们通过go关键字启动了两个goroutine来执行这两个任务函数。最后，通过time.Sleep函数等待1秒钟，确保两个goroutine足够时间执行完毕。

通过运行以上代码，我们可以看到两个goroutine的任务交替执行，而不是同时执行。这就是并发的概念，尽管任务在同一个线程上交替执行，但在时间上感觉上是并行的，因为它们几乎同时发生。

为了实现并行，我们可以将代码进行一些调整：

package main

import (
    "fmt"
    "runtime"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Task %d: %d
", id, i)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 设置使用的最大CPU核心数

    go task(1)
    go task(2)

    // 等待任务完成
    fmt.Scanln()
}

在这个修改后的代码中，我们去除了任务函数中的时间暂停，并通过fmt.Scanln()函数让程序等待用户的输入。这样两个goroutine的任务将真正地同时执行，因为它们没有通过时间暂停被阻塞，这就实现了并行的效果。

通过这个示例，我们可以清晰地看到并发和并行的区别。并发是通过在单线程上交替执行多个任务来提高效率，而并行则是真正地同时运行多个任务在多个处理器上。在Go语言中，通过goroutine和GOMAXPROCS

Mari kita gambarkan perbezaan antara konkurensi dan selari melalui contoh mudah:

rrreee

Dalam kod di atas, kami mentakrifkan dua fungsi tugas, setiap fungsi mencetak maklumat tugas 5 kali dan jeda selama 100 milisaat selepas setiap cetakan. Dalam fungsi main, kami memulakan dua goroutine melalui kata kunci go untuk melaksanakan kedua-dua fungsi tugas ini. Akhir sekali, tunggu selama 1 saat melalui fungsi time.Sleep untuk memastikan kedua-dua gorout mempunyai masa yang mencukupi untuk menyelesaikan pelaksanaan.

Dengan menjalankan kod di atas, kita dapat melihat bahawa tugas kedua-dua goroutine dilaksanakan secara bergilir-gilir dan bukannya serentak. Ini adalah konsep konkurensi, walaupun tugasan dilaksanakan secara bergilir-gilir pada benang yang sama, mereka berasa selari dalam masa kerana ia berlaku pada masa yang hampir sama. 🎜🎜Untuk mencapai keselarian, kami boleh membuat beberapa pelarasan pada kod: 🎜rrreee🎜Dalam kod yang diubah suai ini, kami mengalih keluar jeda masa dalam fungsi tugas dan lulus fungsi fmt.Scanln() Biarkan program menunggu input pengguna. Dengan cara ini, kedua-dua tugas goroutine sebenarnya akan dilaksanakan pada masa yang sama, kerana ia tidak disekat oleh jeda masa, yang mencapai kesan selari. 🎜🎜Melalui contoh ini, kita dapat melihat dengan jelas perbezaan antara concurrency dan parallelism. Concurrency meningkatkan kecekapan dengan melaksanakan berbilang tugas secara berselang-seli pada satu utas, manakala selari benar-benar menjalankan berbilang tugas pada berbilang pemproses pada masa yang sama. Dalam bahasa Go, concurrency dan parallelism boleh dicapai dengan mudah melalui goroutine dan fungsi GOMAXPROCS. 🎜🎜Secara umumnya, menguasai konsep konkurensi dan selari adalah penting untuk memahami aplikasi pengaturcaraan serentak dalam bahasa Go. Hanya dengan memahami secara mendalam perbezaan antara kedua-dua kita boleh menggunakan ciri bahasa Go dengan lebih baik untuk menulis program serentak yang cekap. 🎜🎜Melalui penerokaan artikel ini, saya berharap pembaca akan mempunyai pemahaman yang lebih jelas tentang konsep konkurensi dan selari dalam bahasa Go, dan juga dapat mendalami pemahaman mereka tentang kedua-dua konsep ini melalui contoh kod tertentu. Dalam pengaturcaraan bahasa Go yang sebenar, penggunaan fleksibel bagi teknologi serentak dan selari akan membantu meningkatkan prestasi dan kecekapan program. 🎜

Atas ialah kandungan terperinci Penerokaan perbezaan antara concurrency dan paralelisme dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!