Pergi pengaturcaraan serentak: pengaturcaraan tak segerak dan IO tidak menyekat

Dalam Go, pengaturcaraan tak segerak dan IO tidak menyekat tersedia untuk pengaturcaraan serentak. Pengaturcaraan tak segerak menggunakan Goroutines ringan untuk melaksanakan tugas di latar belakang sementara program utama meneruskan pelaksanaan. IO tidak menyekat menggunakan antara muka io.Reader untuk melaksanakan operasi input/output tanpa menunggu selesai. Kedua-dua konsep ini boleh digunakan dalam aplikasi dunia nyata seperti pemprosesan permintaan web yang cekap.

Go Parallel Programming: Asynchronous Programming and Non-blocking IO

Dalam bahasa Go, asynchronous programming dan non-blocking IO ialah konsep utama dalam pengaturcaraan serentak. Artikel ini akan menyelidiki kedua-dua konsep dan menunjukkan aplikasi dunia sebenar mereka melalui contoh praktikal.

Pengaturcaraan Asynchronous

Pengaturcaraan tak segerak ialah gaya pengaturcaraan di mana acara dikendalikan semasa ia berlaku dan bukannya menunggu untuk selesai. Dalam bahasa Go, pengaturcaraan tak segerak dilaksanakan terutamanya melalui Goroutine. Goroutine ialah utas ringan dalam bahasa Go yang boleh melaksanakan tugas secara serentak di latar belakang.

func main() {
    ch := make(chan string)

    // 启动一个Goroutine
    go func() {
        time.Sleep(1 * time.Second)
        ch <- "Hello, world!"
    }()

    // 主程序从通道中读取数据。如果数据尚未准备好，该行代码将阻塞
    result := <-ch
    fmt.Println(result) // 输出："Hello, world!"
}

Dalam contoh di atas, program utama memulakan Goroutine, yang memproses tugasan di latar belakang. Program utama tidak perlu menunggu Goroutine selesai sebelum meneruskan pelaksanaan, di mana ia boleh melakukan kerja lain.

IO yang tidak menyekat

IO yang tidak menyekat ialah operasi input/output yang tidak menyekat pelaksanaan program sehingga operasi selesai. Dalam bahasa Go, IO tidak menyekat biasanya dilaksanakan menggunakan antara muka io.Reader. io.Reader接口来实现。

import (
    "bytes"
    "io"
    "log"
)

func main() {
    // 创建一个Buffer作为io.Reader
    reader := bytes.NewBufferString("Hello, world!")

    // 创建一个缓冲区并从reader中读取数据
    buf := make([]byte, 1024)
    n, err := reader.Read(buf)
    if err != nil {
        log.Fatal(err)
    }

    // 将读取到的数据转换成字符串
    result := string(buf[:n])
    fmt.Println(result) // 输出："Hello, world!"
}

在上面示例中，我们使用io.Reader

import (
    "fmt"
    "log"
    "net/http"

    // 导入第三方包
    "github.com/gorilla/mux"
)

func main() {
    // 创建一个mux路由器
    router := mux.NewRouter()

    // 使用Goroutine处理请求
    router.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(1 * time.Second)
        fmt.Fprintf(w, "Hello, world!")
    })

    // 监听端口
    log.Fatal(http.ListenAndServe(":8080", router))
}

Dalam contoh di atas, kami menggunakan antara muka io.Reader untuk membaca data daripada Penampan. Operasi baca tidak menyekat, yang bermaksud bahawa program utama tidak akan menyekat walaupun data belum siap lagi.

Kes praktikal

Pengaturcaraan tak segerak dan IO tidak menyekat digunakan secara meluas dalam pembangunan aplikasi. Kes penggunaan biasa ialah mengendalikan permintaan web.

rrreee

Dalam contoh ini, kami mencipta penghala web menggunakan perpustakaan pihak ketiga Gorilla Mux. Kami menggunakan Goroutine untuk mengendalikan permintaan HTTP supaya program utama boleh mengendalikan berbilang permintaan pada masa yang sama.

Kesimpulan

Pengaturcaraan tak segerak dan IO tidak menyekat ialah dua konsep penting dalam pengaturcaraan serentak dalam bahasa Go. Dengan menggunakannya bersama-sama, kami boleh mencipta aplikasi responsif berprestasi tinggi. 🎜

Atas ialah kandungan terperinci Pergi pengaturcaraan serentak: pengaturcaraan tak segerak dan IO tidak menyekat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!