Pengalaman praktikal pengaturcaraan serentak di Golang: daripada Goroutines kepada kelompok berskala besar

Pengalaman praktikal pengaturcaraan serentak Golang: daripada Goroutines kepada kelompok berskala besar

Pengenalan:
Apabila seni bina komputer menjadi semakin kompleks, permintaan untuk konkurensi juga semakin tinggi dan lebih tinggi. Sebagai bahasa pengaturcaraan yang menekankan konkurensi, Golang menyediakan model konkurensi yang berkuasa dan ringkas, memudahkan pembangun menulis program serentak yang cekap. Artikel ini akan memperkenalkan beberapa cerapan tentang pengaturcaraan serentak di Golang, daripada penggunaan asas Goroutines kepada aplikasi praktikal kelompok berskala besar.

1. Penggunaan asas Goroutines
Goroutines adalah sejenis benang ringan di Golang adalah berbeza daripada pelbagai benang tradisional Ia akan berkongsi ruang memori dalam proses yang sama, jadi kos untuk memulakan dan memusnahkan adalah agak rendah. Berikut ialah kod contoh mudah:

package main

import (
    "fmt"
    "time"
)

func main() {
    go task1()
    go task2()

    // 等待任务完成
    time.Sleep(2 * time.Second)

    fmt.Println("All tasks completed!")
}

func task1() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 1 is running...")
        time.Sleep(500 * time.Millisecond)
    }
}

func task2() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 2 is running...")
        time.Sleep(500 * time.Millisecond)
    }
}

Dalam kod di atas, fungsi utama membuka dua Goroutines dan memulakan dua tugas tugas1 dan tugas2. Selepas menunggu untuk menyelesaikan dua tugasan melalui masa. Fungsi tidur, "Semua tugas selesai!" Dengan menjalankan kod di atas, anda boleh melihat bahawa kedua-dua tugas dilaksanakan secara serentak, dan output muncul dalam bentuk berselang-seli.

2. Laksanakan komunikasi antara Goroutines berdasarkan Channel
Di Golang, Goroutines boleh berkomunikasi melalui Channel Channel ialah struktur data serentak yang selamat yang membolehkan Goroutines menghantar dan menerima data dengan selamat. Berikut ialah contoh kod berdasarkan Saluran:

package main

import (
    "fmt"
)

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

    go produce(ch)
    go consume(ch)

    // 等待任务完成
    select {}
}

func produce(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
}

func consume(ch <-chan int) {
    for i := 1; i <= 5; i++ {
        data := <-ch
        fmt.Println("Consumed data:", data)
    }
}

Dalam kod di atas, fungsi utama mencipta Saluran jenis int dan menghantarnya sebagai parameter kepada fungsi menghasilkan dan menggunakan. Fungsi produce menghantar data melalui saluran ch, manakala fungsi penggunaan menerima data melalui saluran ch dan mengeluarkannya. Dengan menjalankan kod di atas, anda boleh melihat bahawa selepas fungsi menghasilkan menghantar data ke saluran ch, fungsi penggunaan serta-merta menerima dan mengeluarkan data daripada saluran ch.

3. Gunakan Goroutines untuk meningkatkan prestasi program
Groutines di Golang boleh mencapai pelaksanaan selari sebenar dan boleh meningkatkan kecekapan pelaksanaan program dengan berkesan. Berikut ialah contoh kod mudah:

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()

    nums := []int{1, 2, 3, 4, 5}
    results := make(chan int)

    for _, num := range nums {
        go square(num, results)
    }

    total := 0
    for i := 0; i < len(nums); i++ {
        total += <-results
    }

    fmt.Println("Total:", total)
    fmt.Println("Execution time:", time.Since(start))
}

func square(num int, results chan<- int) {
    time.Sleep(1 * time.Second) // 模拟耗时操作
    results <- num * num
}

Dalam kod di atas, fungsi utama membuka 5 Goroutines, dan setiap Goroutines akan menghantar hasil segi empat sama nombor input ke saluran hasil. Goroutine utama menerima data daripada saluran keputusan melalui gelung dan mengumpulkan keputusan ke dalam jumlah pembolehubah. Akhirnya, jumlah dan masa pelaksanaan program adalah output. Dengan menjalankan kod di atas, anda dapat melihat bahawa masa pelaksanaan program dipendekkan dengan ketara kerana penggunaan pelaksanaan serentak.

4. Aplikasi praktikal kluster berskala besar
Dalam aplikasi praktikal, model pengaturcaraan serentak Golang boleh digunakan untuk pembinaan kluster berskala besar. Berikut ialah kod contoh perangkak teragih yang dipermudahkan:

package main

import (
    "fmt"
    "sync"
)

func main() {
    urls := []string{"https://www.example.com", "https://www.example.org", "https://www.example.net"}
    results := make(chan string)

    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go crawl(url, results, &wg)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for result := range results {
        fmt.Println("Crawled:", result)
    }
}

func crawl(url string, results chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()

    // 省略具体的爬取逻辑
    results <- url
}

Dalam contoh di atas, fungsi utama mencipta saluran hasil jenis rentetan chan untuk menerima hasil merangkak. Gunakan sync.WaitGroup untuk menunggu semua Goroutine selesai. Setiap Goroutines akan memanggil fungsi rangkak untuk melaksanakan logik rangkak tertentu dan menghantar hasil ke saluran hasil. Goroutine utama memperoleh hasil merangkak dengan membaca saluran hasil dan mengeluarkannya.

Ringkasan:
Melalui pengenalan dan amalan pengaturcaraan serentak Golang ini, kami telah mempelajari tentang penggunaan asas Goroutines, komunikasi berasaskan Saluran, menggunakan konkurensi untuk meningkatkan prestasi program dan aplikasi praktikal kelompok berskala besar. Model pengaturcaraan serentak Golang membolehkan pembangun menulis program serentak yang cekap dan memberikan kemudahan apabila membina kelompok berskala besar. Saya harap artikel ini dapat membantu pembelajaran dan amalan pengaturcaraan serentak di Golang.

Atas ialah kandungan terperinci Pengalaman praktikal pengaturcaraan serentak di Golang: daripada Goroutines kepada kelompok berskala besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!