Apakah goroutine dalam bahasa Go?

Goroutine ialah pelaksanaan utas ringan dalam bahasa Go Ia adalah abstraksi ringan yang dibina pada utas dan diuruskan oleh masa jalan Go. Goroutine membolehkan kami melaksanakan pelbagai fungsi atau kaedah secara selari dalam ruang alamat yang sama pada kos yang sangat rendah berbanding dengan utas, penciptaan dan pemusnahannya jauh lebih murah, dan penjadualannya adalah bebas daripada utas.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Apabila menulis program rangkaian Socket, anda perlu menyediakan kumpulan benang terlebih dahulu untuk memperuntukkan benang bagi setiap paket penghantaran dan penerimaan Soket. Pembangun perlu mewujudkan hubungan yang sepadan antara bilangan utas dan bilangan CPU untuk memastikan setiap tugas boleh diperuntukkan kepada CPU untuk diproses tepat pada masanya, sambil mengelakkan kehilangan kecekapan yang disebabkan oleh penukaran kerap berbilang tugas antara utas .

Walaupun, kumpulan benang menyediakan mekanisme abstrak untuk peruntukan benang untuk penulis logik. Walau bagaimanapun, apabila berhadapan dengan keperluan pemprosesan selaras dan benang yang mungkin berlaku pada bila-bila masa dan di mana-mana sahaja, kumpulan benang tidak begitu intuitif dan mudah. Adakah terdapat mekanisme: jika pengguna memperuntukkan tugas yang mencukupi, sistem secara automatik boleh membantu pengguna memperuntukkan tugas kepada CPU supaya tugasan ini boleh dijalankan serentak yang mungkin. Mekanisme ini dipanggil goroutine dalam bahasa Go.

Goroutine ialah pelaksanaan urutan ringan dalam bahasa Go dan diuruskan oleh masa jalan Go. Program Go akan memperuntukkan tugas dalam goroutine secara bijak kepada setiap CPU.

Goroutine ialah abstraksi ringan yang dibina pada benang. Ia membolehkan kami melaksanakan pelbagai fungsi atau kaedah secara selari dalam ruang alamat yang sama pada kos yang sangat rendah. Berbanding dengan benang, penciptaan dan pemusnahannya jauh lebih murah, dan penjadualannya adalah bebas daripada benang.

Program Go bermula daripada fungsi main() pakej utama Apabila program bermula, program Go akan mencipta goroutine lalai untuk fungsi main().

Buat goroutine menggunakan fungsi biasa

Gunakan kata kunci go dalam program Go untuk mencipta goroutine bagi sesuatu fungsi. Fungsi boleh dibuat dengan berbilang goroutine dan satu goroutine mesti sepadan dengan satu fungsi.

1) Format

Buat goroutine untuk fungsi biasa seperti berikut:

go 函数名( 参数列表 )

• Nama fungsi: Diperlukan Nama fungsi yang akan dipanggil.

• Senarai parameter: Parameter yang perlu dihantar semasa memanggil fungsi.

Apabila menggunakan kata kunci go untuk mencipta goroutine, nilai pulangan bagi fungsi yang dipanggil akan diabaikan.

Jika anda perlu memulangkan data dalam goroutine, sila gunakan ciri saluran yang diperkenalkan kemudian untuk menghantar data keluar dari goroutine sebagai nilai pulangan melalui saluran.

2) Contoh

Gunakan kata kunci go untuk melaksanakan fungsi running() secara serentak dan mencetak pembilang setiap saat, sementara goroutine utama menunggu input pengguna, dua tindakan boleh dilakukan serentak. Sila rujuk kod di bawah:

package main
import (
    "fmt"
    "time"
)
func running() {
    var times int
    // 构建一个无限循环
    for {
        times++
        fmt.Println("tick", times)
        // 延时1秒
        time.Sleep(time.Second)
    }
}
func main() {
    // 并发执行程序
    go running()
    // 接受命令行输入, 不做任何事情
    var input string
    fmt.Scanln(&input)
}

Keluaran baris arahan adalah seperti berikut:

Selepas kod dilaksanakan, baris arahan akan berterusan kutu keluaran, dan anda boleh menggunakan fmt .Scanln() menerima input pengguna. Kedua-dua langkah boleh dijalankan serentak.

Perihalan kod adalah seperti berikut:

• Baris 12, gunakan untuk membentuk gelung tak terhingga.

• Dalam baris 13, pembolehubah masa terus meningkat dalam gelung.

• Baris 14, keluarkan nilai pembolehubah masa.

• Baris 17, gunakan masa.Tidur untuk berhenti seketika selama 1 saat dan kemudian teruskan gelung.

• Baris 25, gunakan kata kunci go untuk membiarkan fungsi running() berjalan serentak.

• Baris 29, terima input pengguna sehingga kekunci Enter ditekan, kandungan input ditulis ke dalam pembolehubah input dan kembali, dan keseluruhan program ditamatkan.

Jujukan pelaksanaan kod ini adalah seperti yang ditunjukkan dalam rajah di bawah.

Rajah: Gambar rajah berjalan serentak

Dalam contoh ini, apabila program Go bermula, masa jalan akan mencipta goroutine untuk fungsi main() secara lalai. Apabila pernyataan go running dilaksanakan dalam goroutine fungsi main(), goroutine kepunyaan fungsi running() dicipta dan fungsi running() mula melaksanakan dalam goroutine sendiri. Pada ketika ini, main() terus dilaksanakan, dan kedua-dua goroutine beroperasi secara serentak melalui mekanisme penjadualan program Go.

Buat goroutine menggunakan fungsi tanpa nama

Kata kunci Go juga boleh memulakan goroutine untuk fungsi atau penutupan tanpa nama.

1) Format mencipta goroutine menggunakan fungsi tanpa nama

Apabila menggunakan fungsi tanpa nama atau penutupan untuk mencipta goroutine, selain menulis bahagian definisi fungsi selepas pergi, Anda juga perlu menambah parameter panggilan bagi fungsi tanpa nama, dalam format berikut:

go func( 参数列表 ){
    函数体
}( 调用参数列表 )

Antaranya:

• Senarai parameter: senarai pembolehubah parameter dalam badan berfungsi.

• Badan fungsi: kod fungsi tanpa nama.

• 调用参数列表：启动 goroutine 时，需要向匿名函数传递的调用参数。

2) 使用匿名函数创建goroutine的例子

在 main() 函数中创建一个匿名函数并为匿名函数启动 goroutine。匿名函数没有参数。代码将并行执行定时打印计数的效果。参见下面的代码：

package main
import (
    "fmt"
    "time"
)
func main() {
    go func() {
        var times int
        for {
            times++
            fmt.Println("tick", times)
            time.Sleep(time.Second)
        }
    }()
    var input string
    fmt.Scanln(&input)
}

代码说明如下：

• 第 10 行，go 后面接匿名函数启动 goroutine。

• 第 12～19 行的逻辑与前面程序的 running() 函数一致。

• 第 21 行的括号的功能是调用匿名函数的参数列表。由于第 10 行的匿名函数没有参数，因此第 21 行的参数列表也是空的。

扩展知识：Goroutine与线程的区别

许多人认为goroutine比线程运行得更快，这是一个误解。Goroutine并不会更快，它只是增加了更多的并发性。当一个goroutine被阻塞（比如等待IO），golang的scheduler会调度其他可以执行的goroutine运行。与线程相比，它有以下的几个优点：

内存消耗更少：

Goroutine所需要的内存通常只有2kb，而线程则需要1Mb（500倍）

创建与销毁的开销更小：

由于线程创建时需要向操作系统申请资源，并且在销毁时将资源归还，因此它的创建和销毁的开销比较大。相比之下，goroutine的创建和销毁是由go语言在运行时自己管理的，因此开销更低。

切换开销更小：

只是goroutine之于线程的主要区别，也是golang能够实现高并发的主要原因。线程的调度方式是抢占式的，如果一个线程的执行时间超过了分配给它的时间片，就会被其他可执行的线程抢占。在线程切换的过程中需要保存/恢复所有的寄存器信息，比如16个通用寄存器，PC（Program Counter）、SP（Stack Pointer）段寄存器等等。而goroutine的调度是协同式的，它不会直接地与操作系统内核打交道。当goroutine进行切换的时候，之后很少量的寄存器需要保存和恢复（PC和SP）。因此goroutine的切换效率更高。

【相关推荐：Go视频教程、编程教学】

Atas ialah kandungan terperinci Apakah goroutine dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!