गो सर्वर में समवर्ती (एक साथ) HTTP कनेक्शन की सैद्धांतिक अधिकतम संख्या क्या है?

Question

समवर्ती HTTP कनेक्शन की संख्या पर ऊपरी सीमा क्या है जो गो में लागू एक बहुत ही सरल सर्वर संभाल सकता है?

Answer 1

समवर्ती HTTP कनेक्शन की संख्या उपलब्ध स्मृति और ऑपरेटिंग सिस्टम सीमाओं द्वारा सीमित है।

लिनक्स में, मुलायम ऑपरेटिंग सिस्टम की सीमाएं - जैसे कि खुली फ़ाइलों की अधिकतम संख्या - ulimit का उपयोग करके मुद्रित और बदला जा सकता है।

स्मृति के मामले में, 32-बिट लिनक्स पर चल रहे न्यूनतम गो HTTP सर्वर में प्रत्येक HTTP कनेक्शन 21 KiB स्मृति (इस सर्वर का स्रोत कोड, गो संस्करण 2013-03-23 ​​के साथ संकलित है) नीचे)। 64-बिट लिनक्स पर, स्मृति खपत अधिक होने की उम्मीद की जा सकती है।

32-बिट सिस्टम पर सर्वर के लिए 1 जीबी मेमोरी उपलब्ध है, 21 कीबी का मतलब है कि लगभग 50,000 एक साथ कनेक्शन संभव हैं। यह में लिनक्स कर्नेल द्वारा उपभोग की गई स्मृति शामिल है।

package main 

import (
    "flag" 
    "fmt" 
    "net/http" 
    "os" 
    "runtime" 
    "sync" 
) 

var isClient = flag.Bool("client", false, "Whether to start the HTTP server or the HTTP client") 
var N = flag.Int("n", 1000, "Number of concurrent HTTP requests") 

var wait = make(chan byte) 
var counter = 0 
var reachedN = make(chan byte) 

func handler(w http.ResponseWriter, req *http.Request) { 
    fmt.Fprintf(w, "some text") 
    counter++ 
    if counter == *N { 
     reachedN <- 0 
    } 
    <-wait // Block this goroutine 
} 

func main() { 
    flag.Parse() 
    if *N <= 0 { 
     fmt.Fprintf(os.Stderr, "invalid number of goroutines") 
     os.Exit(1) 
    } 

    if *isClient { 
     // Initiate N http connections 
     var wg sync.WaitGroup 
     for i := 0; i < *N; i++ { 
      wg.Add(1) 
      go func(ii int) { 
       _, err := http.Get("http://127.0.0.1:12345") 
       if err != nil { 
        fmt.Fprintf(os.Stderr, "client %d: %s\n", ii, err) 
        os.Exit(1) 
       } 
       wg.Done() 
      }(i) 
     } 
     wg.Wait() 
    } else { 
     runtime.GOMAXPROCS(1) // No concurrency 

     // Read MemStats 
     var m0 runtime.MemStats 
     runtime.ReadMemStats(&m0) 

     go func() { 
      <-reachedN // Wait until there are *N concurrent requests 

      // Read MemStats 
      var m1 runtime.MemStats 
      runtime.ReadMemStats(&m1) 

      fmt.Printf("Number of HTTP connections:  %d\n", *N) 
      fmt.Printf("Memory consumption per connection: %.2f bytes\n", float64(m1.Sys-m0.Sys)/float64(*N)) 
      os.Exit(1) 
     }() 

     http.HandleFunc("/", handler) 
     err := http.ListenAndServe(":12345", nil) 
     if err != nil { 
     fmt.Fprintf(os.Stderr, "server: %s\n", err) 
      os.Exit(1) 
     } 
    } 
}