Explication détaillée des cas d'utilisation et des scénarios de programmation simultanée Go

La programmation simultanée est implémentée dans Go through goroutine, permettant d'exécuter plusieurs tâches simultanément pour améliorer l'efficacité. Ses cas d'utilisation incluent : Traitement parallèle Traitement des événements Opérations intensives d'E/S Planification des tâches du service HTTP

Explication détaillée des cas d'utilisation et des scénarios de la programmation simultanée Go

Introduction
La programmation simultanée est un paradigme de programmation qui permet nous Effectuer plusieurs tâches simultanément. Dans le langage Go, la programmation simultanée est implémentée via des goroutines, qui sont des threads légers. Cet article explorera les cas d'utilisation et les scénarios de programmation simultanée dans Go et fournira des exemples pratiques.

Cas d'utilisation et scénarios

1. Traitement parallèle

• Divisez les tâches volumineuses en sous-tâches plus petites et traitez-les en parallèle pour améliorer l'efficacité.
• Exemple : utilisez Goroutines pour paralléliser les tâches de traitement d'image.

2. Gestion des événements

• Écoutez les événements entrants et utilisez goroutine pour traiter chaque événement en parallèle.
• Exemple : Utilisation de Goroutines pour gérer les messages entrants provenant d'une connexion WebSocket.

3. Opérations gourmandes en E/S

• Pour les opérations gourmandes en E/S, telles que la lecture de fichiers ou les appels réseau, l'utilisation de Goroutines peut améliorer les performances.
• Exemple : Utiliser Goroutines pour lire les données de plusieurs fichiers en parallèle.

4. Service HTTP

• Dans le service HTTP, l'utilisation de Goroutines pour gérer les requêtes entrantes peut améliorer la simultanéité.
• Exemple : utilisez Goroutines pour gérer les requêtes HTTP entrantes provenant d'un serveur Web.

5. Planification des tâches

• Utilisez Goroutines pour gérer et planifier les tâches qui doivent être exécutées à une heure précise ou périodiquement.
• Exemple : utilisez Goroutine pour implémenter la minuterie Cron afin de planifier des tâches.

Exemples pratiques

Exemple 1 : Traitement simultané d'images

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)
}

Exemple 2 : Traitement des messages 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
        }) { }
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!