Pelaksanaan konkurensi dalam bahasa golang

Golang ialah bahasa pengaturcaraan yang dibangunkan oleh Google untuk aplikasi sebelah pelayan. Ia mempunyai ciri-ciri prestasi konkurensi yang berkuasa, jadi ia telah digunakan secara meluas dalam sistem teragih dan pembangunan aplikasi konkurensi tinggi berskala besar. Artikel ini terutamanya memperkenalkan pelaksanaan konkurensi dalam bahasa Golang.

1. Concurrency dan Parallelism

Sebelum bercakap tentang pelaksanaan concurrency Golang, kita perlu memahami dua konsep concurrency dan parallelism. Concurrency merujuk kepada keupayaan untuk melaksanakan berbilang tugas pada masa yang sama, mungkin dalam program yang sama. Paralelisme merujuk kepada keupayaan untuk melaksanakan pelbagai tugas secara serentak. Realisasi konkurensi memerlukan penggunaan benang, proses dan mekanisme lain sistem pengendalian, manakala paralelisme memerlukan penggunaan keupayaan perkakasan seperti CPU berbilang teras. Ringkasnya, keselarasan Golang dilaksanakan dalam satu utas, dan selari dilaksanakan dalam berbilang utas.

2. Model konkurensi Golang

Model konkurensi Golang adalah berdasarkan dua konsep Goroutine dan Channel. Goroutine ialah benang ringan yang disediakan oleh Golang, yang dilaksanakan berdasarkan coroutine. Berbanding dengan benang, overhed untuk mencipta dan memusnahkan Goroutines adalah sangat kecil, dan overhed menukar antara Goroutines juga sangat kecil Oleh itu, sejumlah besar Goroutines boleh dibuka untuk melaksanakan tugas, dengan itu meningkatkan prestasi serentak aplikasi.

Sepenting Goroutine ialah Saluran. Saluran ialah mekanisme komunikasi selamat benang yang disediakan oleh Golang. Melalui Saluran, Goroutines boleh berkomunikasi dan menyelaraskan pelaksanaan untuk mencapai perkongsian data dan kerja kolaboratif, di samping mengelakkan masalah seperti persaingan yang mungkin berlaku apabila berbilang benang serentak.

3. Cara membuat dan memanggil Goroutine

Goroutine boleh dibuat dan dipanggil menggunakan kata kunci go. Berikut ialah contoh mudah:

func main() {
    go func() {
        fmt.Println("This is a Goroutine!")
    }()
    fmt.Println("This is the main function!")
    time.Sleep(time.Second)
}

Dalam contoh di atas, kami menggunakan kata kunci go untuk mencipta Goroutine. Fungsi dalam Goroutine dilaksanakan menggunakan fungsi tanpa nama. Sebelum mengeluarkan rentetan "Ini adalah Goroutine!", atur cara akan mengeluarkan rentetan "Ini adalah fungsi utama!". Memandangkan Goroutine dilaksanakan secara tak segerak, aplikasi tidak menunggu pelaksanaan Goroutine, tetapi keluar terus. Kita boleh menggunakan fungsi Tidur dalam pakej masa untuk membuat benang menunggu untuk tempoh masa tertentu supaya Goroutine mempunyai masa untuk dilaksanakan.

4. Penggunaan Saluran

Saluran ialah mekanisme komunikasi selamat benang yang disediakan oleh Golang. Ia boleh digunakan untuk menyegerakkan maklumat dan berkongsi data antara Goroutines untuk mengelakkan isu persaingan antara berbilang Goroutines.

Menggunakan Saluran adalah sangat mudah. Mula-mula kita perlu membuat Saluran. Mencipta Saluran memerlukan menentukan jenis elemen dalam Saluran. Berikut ialah contoh mencipta Saluran:

ch := make(chan int)

Dalam contoh ini, kami menggunakan fungsi make untuk mencipta Saluran dengan elemen jenis int.

Untuk menghantar data ke Saluran, anda boleh menghubungi kaedah penghantaran Saluran (menggunakan operator <-), seperti yang ditunjukkan di bawah:

ch <- 10

Dalam contoh ini, kami menghantar int taip ke Data Saluran 10. Jika Saluran penuh, operasi disekat sehingga terdapat ruang dalam Saluran.

Untuk menerima data daripada Saluran, anda boleh menghubungi kaedah terima Saluran (menggunakan operator <-), seperti yang ditunjukkan di bawah:

n := <-ch

Dalam contoh ini, kami menerima jenis int daripada Data Saluran n. Jika Saluran kosong, operasi juga akan disekat sehingga terdapat data dalam Saluran.

Saluran juga mempunyai operasi lain, seperti kaedah tutup untuk menutup Saluran, fungsi len untuk mendapatkan bilangan elemen dalam Saluran, dsb.

5. Contoh Pengaturcaraan Serentak Golang

Di bawah ini kami menggunakan contoh mudah untuk menunjukkan pelaksanaan serentak Golang.

Andaikan kita perlu mengira purata semua elemen dalam tatasusunan. Oleh kerana bilangan elemen yang banyak dalam tatasusunan, pengiraan mungkin memakan masa. Kita boleh menggunakan mekanisme konkurensi Golang untuk mempercepatkan pengiraan.

Pertama, kami mentakrifkan tatasusunan yang mengandungi 100 elemen jenis int. Kemudian kami mencipta 10 Goroutine untuk mengira nilai setiap elemen dalam tatasusunan, dan akhirnya menambah jumlah semua elemen dan membahagikan dengan bilangan elemen untuk mendapatkan purata.

func main() {
    a := make([]int, 100)
    for i := 0; i < len(a); i++ {
        a[i] = i
    }

    count := 10
    resultChan := make(chan int, count)
    chunkSize := len(a) / count

    for i := 0; i < count; i++ {
        startIndex := i * chunkSize
        endIndex := (i + 1) * chunkSize
        if i == count-1 {
            endIndex = len(a)
        }
        go sumChunk(a[startIndex:endIndex], resultChan)
    }

    total := 0
    for i := 0; i < count; i++ {
        total += <-resultChan
    }

    fmt.Println("Average value of array is: ", float32(total)/float32(len(a)))
}

func sumChunk(chunk []int, resultChan chan int) {
    sum := 0
    for _, v := range chunk {
        sum += v
    }
    resultChan <- sum
}

Dalam contoh ini, kami mentakrifkan tatasusunan jenis int a dengan panjang 100. Untuk tatasusunan a panjang len(a), kami mencipta kiraan (di sini 10) Goroutines untuk mengira jumlah semua elemen dalam tatasusunan a. Setiap Goroutine mengira jumlah jujukan tatasusunan a dan menghantar hasilnya kepada resultChan. Akhir sekali, kami menerima keputusan setiap Goroutine daripada resultChan dan menambahnya bersama-sama untuk mendapatkan jumlah semua elemen dan mengira purata semua elemen.

Dalam amalan, kami biasanya menetapkan bilangan Goroutine berdasarkan keperluan pengiraan. Jika berbilang teras CPU boleh digunakan, kita boleh menetapkan bilangan Goroutine kepada bilangan teras CPU. Jika tidak, kita perlu menetapkan bilangan Goroutine yang diperlukan untuk menggunakan sumber CPU secara munasabah. Apabila terdapat terlalu banyak Goroutine, sistem mungkin menghadapi masalah seperti penukaran konteks, mengakibatkan kemerosotan prestasi.

Atas ialah kandungan terperinci Pelaksanaan konkurensi dalam bahasa golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!