Bagaimana untuk menggunakan multithreading dalam Go?

Go ialah bahasa pengaturcaraan yang berkuasa dengan sokongan serentak yang kaya. Menggunakan multithreading dalam Go adalah sangat mudah, dan ia merupakan ciri penting Go. Dalam artikel ini, kami akan meneroka cara menggunakan multithreading dalam Go dan sebab teknik ini sangat berguna.

Apakah itu multi-threading?

Multi-threading ialah kaedah pengaturcaraan serentak yang membenarkan berbilang serpihan kod program dilaksanakan serentak dalam program yang sama. Kepingan kod ini dipanggil benang. Setiap utas mempunyai laluan pelaksanaannya sendiri, dan berbilang utas boleh dilaksanakan secara serentak.

Kelebihan multi-threading ialah ia dapat meningkatkan kecekapan pelaksanaan program. Apabila program perlu melakukan beberapa operasi yang memakan masa, kami boleh meletakkan operasi ini dalam satu urutan, dan kemudian terus melaksanakan kod lain dalam urutan lain untuk mencapai tujuan meningkatkan kecekapan program.

Berbilang benang dalam Go

Bahasa Go menyediakan sokongan untuk pengaturcaraan serentak pada peringkat bahasa. Mekanisme pengaturcaraan serentaknya adalah berdasarkan Goroutine dan Channel. Goroutine ialah benang ringan dalam Go Penciptaan dan pemusnahannya jauh lebih cepat daripada benang tradisional. Saluran ialah kaedah komunikasi antara coroutine, yang menyokong penghantaran mesej segerak dan tak segerak.

Pengaturcaraan berbilang benang menggunakan Goroutine

Mencipta Goroutine baharu adalah sangat mudah dan ia boleh dilakukan dengan kata kunci go. Dalam contoh di bawah, kami mencipta dua Goroutine untuk mencetak beberapa nombor.

package main

import (
    "fmt"
)

func printDigits(start int, end int) {
    for i := start; i <= end; i++ {
        fmt.Println(i)
    }
}

func main() {
    go printDigits(1, 5)
    go printDigits(6, 10)
}

Dalam contoh ini, kami mencipta dua Goroutine untuk melaksanakan fungsi printDigits. Fungsi ini akan mencetak nombor dari awal hingga akhir. Dalam fungsi utama, kami menggunakan kata kunci go untuk mencipta Goroutine. Dengan cara ini, kedua-dua fungsi akan dilaksanakan pada masa yang sama kerana ia diletakkan dalam Goroutine yang berbeza.

Gunakan Saluran untuk komunikasi antara Goroutines

Dalam Go, komunikasi antara Goroutines dilaksanakan melalui Saluran. Saluran ialah jenis khas yang boleh menghantar data antara coroutine. Saluran boleh digunakan untuk menghantar data dan menerima data. Dalam contoh berikut, kami mencipta Saluran untuk menghantar data dari satu Goroutine ke Goroutine yang lain.

package main

import (
    "fmt"
)

func sum(a []int, c chan int) {
    sum := 0
    for _, v := range a {
        sum += v
    }
    c <- sum // 把 sum 发送到通道 c
}

func main() {
    a := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(a[:len(a)/2], c)
    go sum(a[len(a)/2:], c)
    x, y := <-c, <-c // 从通道 c 中接收

    fmt.Println(x, y, x+y)
}

Dalam contoh ini, kami mencipta fungsi jumlah yang akan mengira jumlah nombor dalam kepingan. Fungsi ini akan menerima kepingan dan Saluran sebagai parameter, dan kemudian ia akan menghantar jumlahnya ke Saluran.

Dalam fungsi utama, kami mula-mula membuat kepingan panjang 6 dan membahagikannya kepada dua bahagian. Kami kemudian membuat Saluran untuk menerima jumlah daripada dua Goroutine. Seterusnya, kita memulakan dua Goroutine, setiap Goroutine akan memanggil fungsi jumlah untuk mengira sebahagian daripada hirisan. Akhir sekali, kami menerima jumlah daripada Saluran dan menambah dua jumlah dan mencetaknya.

Ringkasan

Mekanisme pengaturcaraan berbilang benang bagi bahasa Go adalah sangat mudah dan mudah digunakan. Pemprosesan selari dan penghantaran data boleh dicapai dengan mudah menggunakan Goroutine dan Channel. Teknik ini boleh meningkatkan kecekapan program, terutamanya apabila memproses data berskala besar. Untuk aplikasi yang memerlukan keselarasan yang cekap, bahasa Go ialah pilihan yang sangat baik.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan multithreading dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!