Corak konkurensi dalam Go; kolam pekerja dan kipas-keluar/kipas-masuk

Go terkenal dengan model konkurensi yang luar biasa, tetapi ramai pembangun hanya menumpukan pada goroutin dan saluran. Walau bagaimanapun, corak konkurensi seperti kumpulan pekerja dan kipas keluar/masuk kipas memberikan kecekapan sebenar.

Artikel ini akan membincangkan konsep lanjutan ini, membantu anda memaksimumkan daya pengeluaran dalam aplikasi Go anda.

Mengapa Concurrency Penting

Concurrency membenarkan program melaksanakan tugas dengan cekap, terutamanya apabila menangani tugas seperti operasi I/O, permintaan web atau pemprosesan latar belakang. Dalam Go, goroutine menyediakan cara yang ringan untuk mengurus beribu-ribu tugasan serentak, tetapi tanpa struktur, anda boleh menghadapi kesesakan. Di situlah kumpulan pekerja dan corak kipas keluar/masuk masuk.

Kolam Pekerja

Kumpulan pekerja membolehkan anda mengehadkan bilangan gorout dengan memberikan tugas kepada "pekerja" tetap. Ini menghalang lebihan langganan, mengurangkan penggunaan sumber dan menjadikan pelaksanaan tugas terurus.

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second) // Simulate work
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    var wg sync.WaitGroup

    // Start 3 workers
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    // Send jobs
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    // Wait for workers to finish
    wg.Wait()
    close(results)

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

Dalam contoh ini:

• Kami mempunyai tiga pekerja yang memproses kerja secara serentak.
• Setiap kerja diserahkan kepada pekerja melalui saluran dan keputusan dikumpulkan untuk diproses.

Corak Kipas-Keluar/Masuk

Corak kipas keluar/masuk kipas membolehkan berbilang goroutin memproses tugas yang sama, manakala kipas masuk mengumpulkan hasil kembali ke dalam satu output. Ini berguna untuk membahagikan tugas dan kemudian mengagregatkan hasil.

package main

import (
    "fmt"
    "sync"
    "time"
)

func workerFanOut(id int, tasks <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for task := range tasks {
        fmt.Printf("Worker %d processing task %d\n", id, task)
        time.Sleep(time.Second) // Simulate work
    }
}

func main() {
    var wg sync.WaitGroup
    tasks := make(chan int, 10)

    // Fan-out: Launch multiple workers
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go workerFanOut(i, tasks, &wg)
    }

    // Send tasks
    for i := 1; i <= 9; i++ {
        tasks <- i
    }
    close(tasks)

    // Wait for workers to finish
    wg.Wait()

    fmt.Println("All tasks are processed.")
}

Dalam kod di atas:

• Fan-Out: Kami mencipta berbilang goroutin (pekerja) yang mengendalikan tugas secara serentak.
• Fan-In: Selepas pemprosesan, semua keputusan pekerja boleh diagregatkan untuk pemprosesan selanjutnya.

Corak konkurensi boleh digunakan untuk mengoptimumkan pelayan web, sistem pemprosesan kelompok atau aplikasi terikat I/O. Menggunakan corak seperti kumpulan pekerja dan kipas keluar/masuk kipas memastikan penggunaan sumber yang optimum tanpa kapasiti sistem yang memberangsangkan.

Langkah Seterusnya untuk meningkatkan pengetahuan anda:

• Terokai cara corak ini boleh diperluaskan kepada cabaran serentak yang lain.
• Bina perkhidmatan web masa nyata dengan kumpulan pekerja yang mengurus permintaan.

Kunci kejayaan dalam keselarasan Go ialah struktur. Menguasai corak konkurensi ini akan meningkatkan kemahiran Go anda dan membantu anda menulis aplikasi berprestasi tinggi.

Nantikan maklumat lanjut tentang Pergi dalam siaran seterusnya!

Anda boleh menyokong saya dengan membelikan saya sebuah buku :)

Atas ialah kandungan terperinci Corak konkurensi dalam Go; kolam pekerja dan kipas-keluar/kipas-masuk. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!