Fahami cara urutan dan coroutine berfungsi di Golang

Cara utas dan coroutine berfungsi dalam Golang

Dalam bahasa Go (Golang), utas dan coroutine ialah konsep yang sangat penting, dan ia adalah komponen asas pengaturcaraan serentak. Memahami cara mereka berfungsi adalah penting untuk membangunkan program serentak yang cekap. Artikel ini akan meneroka secara mendalam prinsip kerja urutan dan coroutine di Golang dan menggunakan contoh kod khusus untuk membantu pembaca memahami dengan lebih baik.

1. Cara utas berfungsi

Dalam sistem pengendalian tradisional, utas ialah unit pelaksanaan terkecil, dan setiap utas mempunyai set susunan dan daftar pelaksanaan sendiri. Benang dijadualkan oleh kernel sistem pengendalian Sesuatu benang boleh dianggap sebagai urutan pelaksanaan bebas, dan ia boleh melaksanakan berbilang tugas secara serentak.

Di Golang ada konsep Goroutine yang serupa dengan benang tapi lebih ringan. Goroutine diurus oleh sistem masa jalan bahasa Go, yang membungkus fungsi ke dalam benang ringan. Goroutines dilaksanakan secara serentak, dan berbilang Goroutines boleh dijalankan serentak dalam satu urutan masa jalan bahasa Go menentukan cara menjadualkan Goroutines ini.

Berikut ialah contoh mudah yang menunjukkan cara mencipta dan menggunakan Goroutine di Golang:

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    for i := 0; i < 5; i++ {
        fmt.Println("Hello")
        time.Sleep(1 * time.Second)
    }
}

func main() {
    go sayHello() // 启动一个新的Goroutine
    time.Sleep(3 * time.Second)
    fmt.Println("Main function")
}

Dalam kod di atas, fungsi sayHello() akan dibalut ke dalam Goroutine dan diletakkan dalam kod baharu Dilaksanakan dalam benang. Dalam fungsi utama, kami memulakan Goroutine baharu melalui go sayHello(), dan kemudian fungsi utama meneruskan pelaksanaan. Selepas 3 saat, fungsi utama mencetak "Fungsi utama", dan fungsi dalam Goroutine akan terus mencetak "Hello" sehingga penghujung gelung. sayHello()函数会被包装成一个Goroutine并在一个新的线程中执行。在main函数中，我们通过go sayHello()启动了一个新的Goroutine，然后main函数继续执行。在3秒后，main函数打印"Main function"，而Goroutine中的函数会继续打印"Hello"，直到循环结束。

二、协程的工作原理

在Golang中，协程（Coroutine）是一种轻量级、高效的并发处理方式。与线程不同的是，协程是在用户空间下实现的，并由开发者完全控制。协程可以看作是线程的子集，它的切换由程序员在代码中明确地控制。

协程在Golang中由channel实现通信和同步。通过channel，不同的协程可以安全地互相通信，避免了共享内存的并发访问问题。下面是一个使用channel进行协程通信的示例：

package main

import "fmt"

func sendData(ch chan int) {
    ch <- 1
}

func main() {
    ch := make(chan int)
    
    go sendData(ch)
    
    data := <-ch
    fmt.Println(data)
}

在上面的代码中，我们创建了一个channel，并在sendData()函数中向channel发送了一个整数，然后在主函数中通过

2. Prinsip kerja coroutine

Di Golang, coroutine ialah kaedah pemprosesan serentak yang ringan dan cekap. Tidak seperti urutan, coroutine dilaksanakan dalam ruang pengguna dan dikawal sepenuhnya oleh pembangun. Coroutines boleh dilihat sebagai subset benang, yang pensuisannya dikawal secara eksplisit oleh pengaturcara dalam kod.

Coroutines melaksanakan komunikasi dan penyegerakan di Golang melalui saluran. Melalui saluran, coroutine yang berbeza boleh berkomunikasi antara satu sama lain dengan selamat, mengelakkan masalah akses serentak kepada memori yang dikongsi. Berikut ialah contoh penggunaan saluran untuk komunikasi coroutine: 🎜rrreee🎜Dalam kod di atas, kami mencipta saluran dan menghantar integer ke saluran dalam fungsi sendData(), dan kemudian dalam In the main fungsi, data diterima melalui dan dicetak. Melalui operasi penghantaran dan penerimaan saluran, coroutine boleh berkomunikasi dengan selamat, merealisasikan kerjasama dan penyegerakan antara coroutine. 🎜🎜Ringkasan: 🎜🎜Di Golang, benang dan coroutine adalah komponen penting untuk mencapai pengaturcaraan serentak. Benang dijadualkan oleh kernel sistem pengendalian, dan Goroutines ialah benang ringan yang diuruskan oleh masa jalan bahasa Go. Coroutine ialah kaedah pemprosesan serentak ringan yang dikawal oleh pembangun. Melalui contoh kod khusus, kami dapat memahami dengan lebih baik prinsip kerja benang dan coroutine di Golang. Saya harap artikel ini dapat membantu pembaca lebih memahami dan menggunakan pengaturcaraan serentak. 🎜

Atas ialah kandungan terperinci Fahami cara urutan dan coroutine berfungsi di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!