Detaillierte Erläuterung der Anwendungsfälle und Szenarien der gleichzeitigen Go-Programmierung

Die gleichzeitige Programmierung ist in Go durch Goroutine implementiert, sodass mehrere Aufgaben gleichzeitig ausgeführt werden können, um die Effizienz zu verbessern. Zu seinen Anwendungsfällen gehören: Parallelverarbeitung, Ereignisverarbeitung, E/A-intensive Vorgänge, HTTP-Service-Aufgabenplanung Wir führen mehrere Aufgaben gleichzeitig aus. In der Go-Sprache wird die gleichzeitige Programmierung durch Goroutinen implementiert, bei denen es sich um leichtgewichtige Threads handelt. In diesem Artikel werden die Anwendungsfälle und Szenarien der gleichzeitigen Programmierung in Go untersucht und praktische Beispiele bereitgestellt.

Anwendungsfälle und Szenarien

1. Parallelverarbeitung

Teilen Sie große Aufgaben in kleinere Teilaufgaben auf und verarbeiten Sie sie parallel, um die Effizienz zu verbessern.

• Beispiel: Verwendung von Goroutinen zur Verarbeitung eingehender Nachrichten von einer WebSocket-Verbindung.

• Beispiel: Verwendung von Goroutinen zum parallelen Lesen von Daten aus mehreren Dateien.

• Beispiel: Verwenden Sie Goroutinen, um eingehende HTTP-Anfragen von einem Webserver zu verarbeiten.

• Beispiel: Verwenden Sie Goroutine, um einen Cron-Timer zum Planen von Jobs zu implementieren.

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

  Nach dem Login kopieren
• Beispiel 2: Verarbeitung von WebSocket-Nachrichten

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

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Anwendungsfälle und Szenarien der gleichzeitigen Go-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!