Melaksanakan penyelarasan tugas multi-thread dan multi-coroutine melalui Saluran di Golang

Go menggunakan Saluran untuk merealisasikan kerjasama tugas antara berbilang benang dan berbilang coroutine

Ikhtisar:

Di Golang, kerjasama tugas antara berbilang benang dan berbilang coroutine boleh dicapai dengan mudah dengan menggunakan Saluran. Saluran bertindak sebagai jambatan untuk komunikasi antara benang dan boleh digunakan untuk menghantar dan menerima data. Melalui Saluran, kami boleh merealisasikan perkongsian data dan penyegerakan antara berbilang benang dan berbilang coroutine, dengan itu mencapai pemprosesan tugasan secara kolaboratif.

Contoh kod:

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started job", j)
        time.Sleep(time.Second) // 模拟进行任务处理
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    numJobs := 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= numJobs; a++ {
        <-results
    }
}

Analisis:

Dalam kod di atas, kami mencipta fungsi pekerja untuk mensimulasikan coroutine yang mengendalikan tugas. Fungsi ini menerima tugas daripada saluran kerja dan menghantar hasil pemprosesan ke saluran hasil.

Dalam fungsi utama, kami mencipta saluran pekerjaan dan saluran hasil dan menyampaikannya kepada setiap coroutine pekerja masing-masing. Kami kemudian menggunakan gelung untuk menghantar tugasan ke saluran kerja dan menutup saluran dengan dekat untuk menunjukkan bahawa semua tugasan telah dihantar.

Akhir sekali, kami menggunakan gelung untuk menerima hasil pemprosesan daripada saluran hasil. Memandangkan saiz penimbal bagi saluran keputusan adalah sama dengan bilangan tugasan, semua keputusan pemprosesan tugasan akan diterima.

Jalankan kod dan output adalah seperti berikut:

worker 1 started job 1
worker 2 started job 2
worker 3 started job 3
worker 1 finished job 1
worker 1 started job 4
worker 2 finished job 2
worker 2 started job 5
worker 3 finished job 3
worker 1 finished job 4
worker 2 finished job 5

Seperti yang anda lihat daripada output, tiga coroutine pekerja mula melaksanakan tugas pada masa yang sama dan menghantar keputusan ke saluran keputusan selepas menyelesaikan tugas. Memandangkan saiz penimbal bagi saluran keputusan ialah bilangan tugasan, ia dijamin bahawa keputusan semua tugasan boleh diterima.

Ringkasan:

Melalui Saluran di Golang, kami boleh mencapai kerjasama tugasan antara berbilang benang dan berbilang coroutine dengan mudah. Dengan menggunakan Saluran, kami boleh berkomunikasi dan berkongsi data dengan mudah antara rangkaian, dengan itu meningkatkan keselarasan dan kecekapan program.

Melalui contoh kod dalam artikel ini, saya berharap pembaca dapat memahami dengan lebih mendalam tentang prinsip dan kaedah untuk mencapai kerjasama tugas berbilang benang dan berbilang coroutine melalui Saluran di Golang. Pada masa yang sama, kami juga berharap pembaca dapat menggunakan sepenuhnya ciri Saluran dalam pembangunan sebenar dan memanfaatkan pengaturcaraan serentak Golang.

Atas ialah kandungan terperinci Melaksanakan penyelarasan tugas multi-thread dan multi-coroutine melalui Saluran di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!