$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOENV="/root/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/root/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/root/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/root/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/root/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build513552128=/tmp/go-build -gno-record-gcc-switches"

package main
import (

"context"

"crypto/tls"

"flag"

"fmt"

"io"

"io/ioutil"

"net/http"

"sync"

"time"

)
func fire(ctx context.Context, wg *sync.WaitGroup, r *http.Request, c *http.Client, chGo chan struct{}, chResult chan bool) {

defer wg.Done()

<-chGo
for {
	select {
	case <-ctx.Done():
		return
	default:
		chResult <- true

		resp, err := c.Do(r)
		if err != nil {
			chResult <- false
			continue
		}

		_, err = io.Copy(ioutil.Discard, resp.Body)
		if err != nil {
			chResult <- false
		}
		resp.Body.Close()
	}
}

}
func main() {

flagURL := flag.String("url", "", "URL for the request")

flag.Parse()
if *flagURL == "" {
	panic(fmt.Errorf("URL can not be empty"))
}

req, err := http.NewRequest("GET", *flagURL, nil)
if err != nil {
	panic(err)
}

tp := http.DefaultTransport.(*http.Transport).Clone()
// In the case of HTTPS, disable verification for testing purposes
tp.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

// Bump up connection limits
tp.MaxConnsPerHost = 200
tp.MaxIdleConns = 200
tp.MaxIdleConnsPerHost = 200

// Disable HTTP/2
tp.TLSNextProto = make(map[string]func(string, *tls.Conn) http.RoundTripper)

// First pass is with a shared transport
hClt := &http.Client{Transport: tp}

chGo := make(chan struct{}, 0)
chResult := make(chan bool, 200)

ctx, cancel := context.WithCancel(context.Background())
d := time.Duration(30 * time.Second)

var wgFire sync.WaitGroup
for i:=1; i<=200; i++ {
	wgFire.Add(1)

	// Need to clone request
	//
	// See https://github.com/golang/go/issues/21780
	go fire(ctx, &wgFire, req.Clone(context.Background()), hClt, chGo, chResult)
}

var wgStat sync.WaitGroup
wgStat.Add(1)
go func() {
	defer wgStat.Done()
	var reqs uint64
	var errs uint64

	for {
		v, more := <-chResult
		if !more {
			break
		}
		switch v {
		case true:
			reqs++
		case false:
			errs++
		}
	}
	fmt.Println("\nWorker sharing HTTP transport")
	fmt.Printf("Duration: %v\nRequests: %v\nRequests per second: %v\nErrors: %v\n\n", d, reqs, reqs / uint64(d.Seconds()), errs)
}()

close(chGo)
time.Sleep(d)
cancel()
wgFire.Wait()
close(chResult)
wgStat.Wait()

// Let's go again but with non-shared transports
chGo = make(chan struct{}, 0)
chResult = make(chan bool, 200)

ctx, cancel = context.WithCancel(context.Background())

for i:=1; i<=200; i++ {
	wgFire.Add(1)

	// Here each worker gets their own transport
	hClt := &http.Client{Transport: tp.Clone()}

	// Need to clone request
	//
	// See https://github.com/golang/go/issues/21780
	go fire(ctx, &wgFire, req.Clone(context.Background()), hClt, chGo, chResult)
}

wgStat.Add(1)
go func() {
	defer wgStat.Done()
	var reqs uint64
	var errs uint64

	for {
		v, more := <-chResult
		if !more {
			break
		}
		switch v {
		case true:
			reqs++
		case false:
			errs++
		}
	}
	fmt.Println("Each worker getting a HTTP transport copy")
	fmt.Printf("Duration: %v\nRequests: %v\nRequests per second: %v\nErrors: %v\n", d, reqs, reqs / uint64(d.Seconds()), errs)
}()

close(chGo)
time.Sleep(d)
cancel()
wgFire.Wait()
close(chResult)
wgStat.Wait()

}