Rangka kerja golang manakah yang paling sesuai untuk pengaturcaraan serentak?

Panduan Rangka Kerja Pengaturcaraan Serentak Golang: Goroutines: coroutine ringan untuk mencapai operasi selari; .

Panduan Rangka Kerja Pengaturcaraan Serentak Golang

Pengenalan

Pengaturcaraan serentak adalah penting dalam membina aplikasi berprestasi tinggi dan berskala. Golang menyediakan set primitif konkurensi yang kaya, tetapi memilih rangka kerja yang betul boleh memudahkan dan meningkatkan lagi kecekapan pengaturcaraan serentak. Artikel ini akan meneroka pelbagai rangka kerja pengaturcaraan serentak Golang yang popular dan menunjukkan kes praktikalnya.

1. Goroutines

goroutine ialah coroutine ringan di Golang yang boleh berjalan selari dalam benang yang berbeza. Mereka sangat cekap dan mudah digunakan, terutamanya sesuai untuk tugas intensif CPU.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个 goroutine 来打印消息
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println("Hello, world!")
            time.Sleep(100 * time.Millisecond)
        }
    }()

    // 主协程等待 goroutine 完成
    time.Sleep(10 * time.Second)
}

2. Saluran

Saluran ialah paip yang digunakan untuk komunikasi antara goroutine. Mereka menyediakan cara yang selamat dan cekap untuk lulus nilai dan menyegerakkan operasi.

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个 channel 来传递值
    ch := make(chan string)

    // 创建一个 goroutine 来发送数据到 channel
    go func() {
        ch <- "Hello, world!"
    }()

    // 接收 goroutine 发送的值
    msg := <-ch
    fmt.Println(msg)

    time.Sleep(10 * time.Second)
}

3. WaitGroups

WaitGroups membenarkan coroutine utama menunggu beberapa goroutine selesai. Ini membantu memastikan bahawa pelaksanaan logik utama tidak diteruskan sehingga semua goroutine selesai dijalankan.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个 WaitGroup
    wg := &sync.WaitGroup{}

    // 添加需要等待的 goroutine 数量
    wg.Add(2)

    // 创建并运行 goroutines
    go func() {
        fmt.Println("Goroutine 1")
        wg.Done()
    }()

    go func() {
        fmt.Println("Goroutine 2")
        wg.Done()
    }()

    // 主协程等待 goroutines 完成
    wg.Wait()

    fmt.Println("All goroutines completed")
}

4. Konteks

Konteks menyediakan maklumat kontekstual dalam goroutine seperti pembatalan dan tarikh akhir. Ini membantu mengurus permintaan dan operasi serentak.

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个 context
    ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)

    // 创建一个 goroutine 并传递 context
    go func(ctx context.Context) {
        fmt.Println("Goroutine started")

        // 监听 context 是否已取消
        select {
        case <-ctx.Done():
            fmt.Println("Goroutine canceled")
            return
        }

        // ... 执行其他操作
    }(ctx)

    // 等待 3 秒后取消 context
    time.Sleep(3 * time.Second)
    ctx.Done()
}

Kesimpulan

Golang menyediakan primitif pengaturcaraan serentak yang berkuasa, dan rangka kerja ini memudahkan lagi dan meningkatkan kecekapan pengaturcaraan serentak. Memilih rangka kerja yang betul bergantung pada keperluan khusus aplikasi anda. Dengan memahami rangka kerja ini, pembangun boleh membina program selari berprestasi tinggi dan boleh skala.

Atas ialah kandungan terperinci Rangka kerja golang manakah yang paling sesuai untuk pengaturcaraan serentak?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!