Mengendalikan TCP Accepts dalam Go Concurrency: Adakah Menggunakan Goroutine Dedicated Pendekatan Terbaik?

TCP Accept and Go Concurrency Model

Model concurrency Go menekankan penggunaan saluran untuk komunikasi antara goroutines. Walau bagaimanapun, apabila bekerja dengan pendengar TCP dalam Go, kaedah net.TCPListener.Accept() menyekat goroutine semasa sehingga sambungan diterima, nampaknya bercanggah dengan paradigma konkurensi Go.

Kekurangan Pilihan yang Betul dan Pilihan Menyekat

Tidak seperti sistem terima panggilan, Accept() tidak mempunyai sokongan pilihan yang betul dan keupayaan untuk menetapkan pilihan menyekat untuk soket pelayan. Ini memaksa pembangun untuk menggunakan penyelesaian berikut:

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

Corak ini membenarkan pemultipleksan Accept() dengan saluran lain menggunakan pilih, tetapi ia memperkenalkan goroutine berasingan untuk setiap soket yang didengari.

Adakah Ini Idiom yang Betul?

Pendekatan ini sememangnya sah dan mengikut model serentak Go. Goroutine adalah ringan dan murah, jadi mencipta berbilang gorouti untuk mendengar soket secara amnya boleh diterima.

Pendekatan Alternatif

Untuk keperluan yang lebih canggih, seperti melaksanakan pilihan dengan tamat masa , seseorang boleh menolak sambungan baharu ke saluran dan memultipkannya dengan pemasa:

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

Pendekatan ini membolehkan lebih kawalan ke atas gelagat pilih dan tamat masa.

Kesimpulannya, manakala Terima () blok kaedah, ia masih sesuai dalam model konkurensi Go. Pilihan pendekatan bergantung pada keperluan khusus dan pertimbangan prestasi aplikasi.

Atas ialah kandungan terperinci Mengendalikan TCP Accepts dalam Go Concurrency: Adakah Menggunakan Goroutine Dedicated Pendekatan Terbaik?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!