Golang implementiert Broadcast

Golang ist eine effiziente Programmiersprache, eine von Google entwickelte Sprache. Im modernen Internetbereich ist Golang zweifellos eine sehr wichtige Programmiersprache. Seine hervorragende Leistung und hohe Skalierbarkeit von Anwendungen eignen sich sehr gut für den Aufbau umfangreicher und leistungsstarker Netzwerkanwendungen. Hier stellen wir vor, wie Sie Golang zum Implementieren der Broadcast-Funktion verwenden.

Broadcasting ist eine Methode zum Veröffentlichen von Nachrichten an mehrere Clients. In Kommunikationsprotokollen ist Broadcast die Übertragung eines Informationspakets an eine bestimmte Adresse im Netzwerk, sodass das Paket von allen Computern in der Nähe dieser Adresse erfasst wird. Normalerweise werden Rundsendungen verwendet, um alle über das Eintreten von Ereignissen zu informieren.

In Golang kann die Broadcast-Implementierung die Broadcast-Funktion realisieren, indem Daten gleichzeitig an mehrere Verbindungen gesendet werden. Wir können eine Liste mehrerer Clientverbindungen verwenden und die Nachricht an jeden Client senden. Goroutine und Channel werden hier verwendet, um Broadcasting zu implementieren.

Zuerst müssen wir eine Verbindungsliste erstellen:

type Client struct {
    conn net.Conn
    name string
}

type ConnectionList struct {
    clients map[*Client]bool
    broadcast chan string
    addClient  chan *Client
    removeClient chan *Client
}

Im obigen Code speichert die Client-Struktur die Informationen zum Verbinden des Clients und die ConnectionList-Struktur speichert die Client-Verbindungsliste, einschließlich des Kanals der Broadcast-Nachricht und des Zusatzes und Löschung des verbundenen Kanals.

Hier sind die Funktionen zum Hinzufügen und Löschen von Verbindungen:

func (list *ConnectionList) add(client *Client) {
    list.clients[client] = true
}

func (list *ConnectionList) remove(client *Client) {
    if _, ok := list.clients[client]; ok {
        delete(list.clients, client)
        close(client.conn)
    }
}

Als nächstes erstellen wir weitere Goroutinen und Kanäle, um Verbindungen zu verwalten und Nachrichten an alle verbundenen Clients zu senden:

func handleConnection(conn net.Conn, list *ConnectionList) {
    client := &Client{conn: conn}

    list.addClient <- client
    defer func() {
        list.removeClient <- client
    }()

    for {
        message := make([]byte, 4096)
        length, err := conn.Read(message)

        if err != nil || length == 0 {
            break
        }

        data := strings.TrimSpace(string(message[:length]))

        if len(data) > 0 {
            list.broadcast <- data
        }
    }
}

func (list *ConnectionList) broadcastMessage() {
    for {
        message := <-list.broadcast
        for client := range list.clients {
            _, err := client.conn.Write([]byte(message + "
"))

            if err != nil {
                list.removeClient <- client
            }
        }
    }
}

func (list *ConnectionList) handleClients() {
    for {
        select {
        case client := <-list.addClient:
            list.add(client)
        case client := <-list.removeClient:
            list.remove(client)
        case <-time.After(60 * time.Second):
            fmt.Println("Keep alive.")
        }
    }
}

handleConnection-Funktion verarbeitet Verbindungsanfragen. Falls vorhanden, wird sie hinzugefügt zur Verbindungsliste hinzufügen. Broadcast-Nachrichten werden über die BroadcastMessage-Funktion verarbeitet. Schließlich wird die Funktion handleClients für immer ausgeführt, sodass die Liste der Verbindungen lange Zeit aktiv bleibt.

Methoden miteinander kombinieren:

func main() {
    list := &ConnectionList{
        clients: make(map[*Client]bool),
        broadcast: make(chan string),
        addClient:  make(chan *Client),
        removeClient: make(chan *Client),
    }

    go list.broadcastMessage()
    go list.handleClients()

    listen, err := net.Listen("tcp", ":6000")
    if err != nil {
        fmt.Println(err)
        return
    }

    defer listen.Close()

    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }

        go handleConnection(conn, list)
    }
}

In diesem einfachen Beispiel können wir Golang verwenden, um die Funktion des Sendens von Nachrichten zu implementieren. Wie Sie sehen, ist Golang effizient, zuverlässig und flexibel, was es zur idealen Wahl für die Erstellung leistungsstarker verteilter Anwendungen macht.

Das obige ist der detaillierte Inhalt vonGolang implementiert Broadcast. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!