Golang implémente la diffusion

Golang est un langage de programmation efficace, c'est un langage développé par Google. Dans le domaine Internet moderne, Golang est sans aucun doute un langage de programmation très important. Ses excellentes performances et sa haute évolutivité des applications sont très adaptées à la création d'applications réseau à grande échelle et hautes performances. Nous allons présenter ici comment utiliser Golang pour implémenter la fonction de diffusion.

La diffusion est une méthode de publication de messages vers plusieurs clients. Dans les protocoles de communication, la diffusion est la transmission d'un paquet d'informations à une adresse spécifique sur le réseau afin que le paquet soit capturé par tous les ordinateurs situés à proximité de cette adresse. Habituellement, les émissions sont utilisées pour informer tout le monde de la survenance d'événements.

Dans Golang, l'implémentation de diffusion peut réaliser la fonction de diffusion en envoyant des données à plusieurs connexions en même temps. Nous pouvons utiliser une liste de plusieurs connexions client et envoyer le message à chaque client. Goroutine et Channel sont utilisés ici pour mettre en œuvre la diffusion.

Tout d'abord, nous devons créer une liste de connexions :

type Client struct {
    conn net.Conn
    name string
}

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

Dans le code ci-dessus, la structure Client enregistre les informations de connexion du client, et la structure ConnectionList enregistre la liste de connexions client, y compris le canal du message diffusé et l'ajout et suppression du canal connecté.

Voici les fonctions d'ajout et de suppression pour les connexions :

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

Ensuite, nous créerons plus de goroutines et de canaux pour gérer les connexions et diffuser des messages à tous les clients connectés :

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

la fonction handleConnection gère les demandes de connexion, si elle est présente, elle est ajoutée à la liste des connexions. Les messages diffusés sont traités via la fonction BroadcastMessage. Enfin, la fonction handleClients s'exécute indéfiniment afin que la liste des connexions reste active longtemps.

Combiner des méthodes ensemble :

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

Dans cet exemple simple, nous pouvons utiliser Golang pour implémenter la fonction de diffusion de messages. Comme vous pouvez le constater, Golang est efficace, fiable et flexible, ce qui en fait un choix idéal pour créer des applications distribuées hautes performances.

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!