Gestion des acceptations TCP dans Go Concurrency : l'utilisation d'un Goroutine dédié est-elle la meilleure approche ?

Modèle de concurrence TCP Accept and Go

Le modèle de concurrence Go met l'accent sur l'utilisation de canaux pour la communication entre les goroutines. Cependant, lorsque vous travaillez avec des écouteurs TCP dans Go, la méthode net.TCPListener.Accept() bloque la goroutine actuelle jusqu'à ce qu'une connexion soit acceptée, ce qui semble contredire le paradigme de concurrence Go.

Manque de sélection appropriée et Options de blocage

Contrairement aux appels d'acceptation du système, Accept() ne prend pas en charge la sélection appropriée et ne permet pas de définir des options de blocage pour les sockets du serveur. Cela oblige les développeurs à recourir à la solution de contournement suivante :

<code class="go">acceptChannel = make(chan *Connection)
go func() {
  for {
   rw, err := listener.Accept()
   if err != nil { ... handle error ... close(acceptChannel) ... return }
   s.acceptChannel <- &Connection{tcpConn: rw, .... }
  }
}()</code>

Ce modèle permet de multiplexer Accept() avec d'autres canaux à l'aide de select, mais il introduit une goroutine distincte pour chaque socket écoutée.

Est-ce l'idiome correct ?

Cette approche est en effet valide et suit le modèle de concurrence Go. Les goroutines sont légères et peu coûteuses, donc la création de plusieurs goroutines pour l'écoute des sockets est généralement acceptable.

Approche alternative

Pour des exigences plus sophistiquées, telles que la mise en œuvre d'une sélection avec un délai d'attente , on peut pousser de nouvelles connexions vers un canal et le multiplexer avec une minuterie :

<code class="go">newConns := make(chan net.Conn)

// For every listener spawn the following routine
go func(l net.Listener) {
    for {
        c, err := l.Accept()
        if err != nil {
            // handle error
            newConns <- nil
            return
        }
        newConns <- c
    }
}(listener)

for {
    select {
    case c := <-newConns:
        // new connection or nil if acceptor is down
    case <-time.After(time.Minute):
        // timeout branch
    }
}</code>

Cette approche permet plus de contrôle sur le comportement de sélection et de délai d'attente.

En conclusion, alors que l'option Accepter (), elle s'inscrit toujours dans le modèle de concurrence Go. Le choix de l'approche dépend des exigences spécifiques et des considérations de performances de l'application.

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!