Penjelasan terperinci tentang kes penggunaan dan senario pengaturcaraan serentak Go

Pengaturcaraan serentak dilaksanakan dalam Go through goroutine, membolehkan berbilang tugasan dilaksanakan serentak untuk meningkatkan kecekapan. Kes penggunaannya termasuk: Pemprosesan selari Pemprosesan acara Operasi intensif I/O Penjadualan tugas perkhidmatan HTTP

Penjelasan terperinci tentang kes penggunaan dan senario pengaturcaraan serentak Go

Pengenalan
membolehkan pengaturcaraan serentak kami Melaksanakan pelbagai tugas serentak. Dalam bahasa Go, pengaturcaraan serentak dilaksanakan melalui goroutine, yang merupakan benang ringan. Artikel ini akan meneroka kes penggunaan dan senario pengaturcaraan serentak dalam Go dan memberikan contoh praktikal.

Gunakan Kes dan Senario

1. Pemprosesan Selari

• Pecahkan tugasan besar kepada subtugas yang lebih kecil dan prosesnya secara selari untuk meningkatkan kecekapan.
• Contoh: Gunakan Goroutines untuk menyelaraskan tugas pemprosesan imej.

2. Pengendalian acara

• Dengar acara masuk dan gunakan goroutine untuk memproses setiap acara secara selari.
• Contoh: Menggunakan Goroutines untuk mengendalikan mesej masuk daripada sambungan WebSocket.

3. Operasi intensif I/O

• Untuk operasi intensif I/O, seperti membaca fail atau panggilan rangkaian, menggunakan Goroutines boleh meningkatkan prestasi.
• Contoh: Menggunakan Goroutines untuk membaca data daripada berbilang fail secara selari.

4. Perkhidmatan HTTP

• Dalam perkhidmatan HTTP, menggunakan Goroutines untuk mengendalikan permintaan masuk boleh meningkatkan keselarasan.
• Contoh: Gunakan Goroutines untuk mengendalikan permintaan HTTP yang masuk daripada pelayan web.

5. Penjadualan Tugasan

• Gunakan Goroutines untuk mengurus dan menjadualkan tugasan yang perlu dilaksanakan pada masa tertentu atau secara berkala.
• Contoh: Gunakan Goroutine untuk melaksanakan pemasa Cron untuk menjadualkan kerja.

Contoh praktikal

Contoh 1: Pemprosesan imej serentak

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "runtime"
)

func main() {
    width, height := 1000, 1000
    images := []image.Image{}

    // 并行创建 100 个图像
    for i := 0; i < 100; i++ {
        img := image.NewRGBA(image.Rect(0, 0, width, height))
        draw.Draw(img, img.Bounds(), &image.Uniform{color.RGBA{0, 0, 0, 255}}, image.ZP, draw.Src)
        images = append(images, img)
    }

    // 计算创建图像所花费的时间
    numCPUs := runtime.NumCPU()
    start := time.Now()
    for i := 0; i < 100; i++ {
        go createImage(images[i])
    }

    // 等待所有 Goroutine 完成
    time.Sleep(10 * time.Second)
    elapsed := time.Since(start)
    fmt.Printf("Creating %d images using %d CPUs took %s\n", len(images), numCPUs, elapsed)
}

func createImage(img image.Image) {
    // 模拟耗时的图像处理操作
    time.Sleep(500 * time.Millisecond)
}

Contoh 2: Memproses mesej WebSocket

package main

import (
    "errors"
    "fmt"
    "net/http"
    "sync/atomic"

    "github.com/gorilla/websocket"
)

type client struct {
    conn *websocket.Conn
    name string
}

var (
    upgrader = websocket.Upgrader{}
    messages = make(chan string)
)

var connectedClients uint64

func main() {
    http.HandleFunc("/websocket", serveWebSocket)

    // 启动 Goroutine 来处理传入消息
    go handleMessage()

    if err := http.ListenAndServe(":8080", nil); err != nil {
        fmt.Println(err)
    }
}

func serveWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    atomic.AddUint64(&connectedClients, 1)

    go handleConnection(conn)
}

func handleConnection(conn *websocket.Conn) {
    defer func() {
        conn.Close()
        atomic.AddUint64(&connectedClients, -1)
    }()

    // 监听来自客户端的消息
    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                fmt.Println(err)
            }
            return
        }

        messages <- message
    }
}

func handleMessage() {
    for message := range messages {
        // 处理消息逻辑
        fmt.Println("Received message:", message)

        // 例如，将消息广播给所有已连接的客户端
        for clients.Range(func(_, v interface{}) bool {
            client := v.(client)
            if err := client.conn.WriteMessage(websocket.TextMessage, []byte(message)); err != nil {
                if errors.Is(err, websocket.ErrCloseSent) {
                    clients.Delete(client.name)
                    fmt.Printf("Client %s disconnected\n", client.name)
                }
            }
            return true
        }) { }
    }
}

Atas ialah kandungan terperinci Penjelasan terperinci tentang kes penggunaan dan senario pengaturcaraan serentak Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!