Coroutines Golang dan model konkurensi

Coroutines in Go ialah mekanisme serentak ringan yang membolehkan berbilang tugasan dilaksanakan dalam proses yang sama. Mereka berkongsi ruang memori proses dan boleh berkomunikasi melalui saluran. Selain itu, artikel itu menyediakan perkara berikut: Penciptaan Coroutine menggunakan kata kunci pergi. Saluran dicipta dengan fungsi buat dan boleh digunakan untuk menghantar nilai antara coroutine. Kes praktikal menunjukkan cara menggunakan coroutine untuk melaksanakan pengkomputeran selari, dan mengira 100,000 nombor perdana melalui 8 coroutine.

Go Coroutines dan Model Concurrency

Pengenalan

Coroutines ialah mekanisme serentak ringan dalam bahasa Go yang membenarkan berbilang tugas bebas dijalankan dalam proses yang sama. Artikel ini akan meneroka coroutine dan model konkurensi dalam Go dan memberikan contoh praktikal.

Coroutines

Coroutines ialah unit pelaksanaan serentak dalam bahasa Go, serupa dengan urutan, tetapi lebih ringan. Coroutine berkongsi ruang memori proses yang sama dan boleh berkongsi data dengan mudah. Cipta coroutine menggunakan kata kunci go seperti berikut:

go func() {
    // 协程体
}

Saluran

Saluran ialah mekanisme komunikasi dalam Go yang digunakan untuk menghantar nilai antara coroutine. Saluran boleh menjadi satu arah atau dua arah, dan boleh ditimbal atau tidak ditimbal. Cipta saluran menggunakan fungsi make, seperti yang ditunjukkan di bawah:

ch := make(chan int, 10)

Kes Amalan: Pengkomputeran Selari

Mari kita gunakan coroutine untuk melaksanakan kes praktikal pengkomputeran selari. Kami mencipta kumpulan coroutine dan mengira jadual besar nombor perdana dalam setiap coroutine:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const primeCount = 100000

// 计算素数
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 协程函数
func parallelPrimes(ch chan int) {
    for i := 0; i < primeCount; i++ {
        n := rand.Intn(100000)
        if isPrime(n) {
            ch <- n
        }
    }
}

func main() {
    // 创建通道和协程池
    ch := make(chan int, primeCount)
    for i := 0; i < 8; i++ {
        go parallelPrimes(ch)
    }

    // 等待协程池完成
    close(ch)

    start := time.Now()
    // 收集素数
    for prime := range ch {
        fmt.Println(prime)
    }
    elapsed := time.Since(start)
    fmt.Printf("Elapsed time: %v\n", elapsed)
}

Dalam kes ini, kami mencipta 8 coroutine, setiap satunya bertanggungjawab untuk mengira 100,000 nombor perdana. Coroutine utama bertanggungjawab untuk mengumpul nombor perdana dan mencetaknya ke konsol.

Atas ialah kandungan terperinci Coroutines Golang dan model konkurensi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!