Go http server 高并发

先来个段子：【并发处理连接数】

多高？

很高！

到底多高？

没有一亿，都算少了！

然后就没有然后了。。。

“段子 END”

这就是目前中国企业的通病：提个概念，没有答案，最后造成概念也模糊了，其实，我感觉它根本不知道要干什么！从头到脚都是病啊！

下面，我们谈谈，web服务连接和速度问题

现在，随着网络普及，对于服务的响应速度和并发处理能力都有了不同寻常的要求

所以，对于服务的标准也越来越高

我以最简洁的说法把问题描述一下，其它不解释

1. 响应速度，是指：对于客户端请求的事务处理时间的快慢，一般，要用分布式处理来快速得到可以分布式处理的事务的结果

2. 并发处理，是指：对于客户端的请求的事务可以并行在服务端处理，一盘要有线程池，工作者的逻辑概念介入

需要澄清一个概念，并发不是指客户端并发连接到服务器！！！！！！，这个是大多数中国开发者的死穴，而且死不悔改！！！！！

所以，你要好好考虑一下，这些固执的人群里，算不算有你有一个！！！

3. 服务器硬件性能越高，自然并发能力越高（多CPU，多内核）；分布式算法优秀，自然响应越快了

好吧，关于文字，我就算这么多，我的博文不是教小白上路的，而是给学者指出路上哪里有坑的。希望你好好揣摩，也许直到今天你也是不懂web的吧

//DEMO

下面，还是上例程，出自于国外的一篇文章。

原作者，出于公司商业性质，说了90%的话，剩下的10%有问题，这些都体现在他给出的源码里露出了马脚，当然这就是把正确改不能用的代价。原谅他吧，搁你身上也一样。这就是公司，万恶的公司，不关作者的事，他只是想得意一下而已！

如果你看了他的文章和源码，你还是跑不起来的，所以，听我的，看我的吧

还是那句话，不过多解释，但不会不说明，如果你需要掰着指头教你写1，2，3，那么请回到亲爱的小学，去找老去的园丁吧，哈哈哈（对了，推荐电影:神秘代码）

/////////////////////////////////////

//go-server-effic.go

package main

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

var (
　　//Max_Num = os.Getenv("MAX_NUM")
　　MaxWorker = runtime.NumCPU()
　　MaxQueue = 1000
)

type Serload struct {
　　pri string
}

type Job struct {
　　serload Serload
}

var JobQueue chan Job

type Worker struct {
　　WorkerPool chan chan Job
　　JobChannel chan Job
　　Quit chan bool
}

func NewWorker(workPool chan chan Job) Worker {
　　return Worker {
　　　　WorkerPool:workPool,
　　　　JobChannel:make(chan Job),
　　　　Quit:make(chan bool),
　　}
}

func (w Worker) Start() {
　　go func() {
　　　　for {
　　　　　　w.WorkerPool <- w.JobChannel
　　　　　　select {
　　　　　　case job:= <- w.JobChannel:
　　　　　　　　// excute job
　　　　　　　　fmt.Println(job.serload.pri)
　　　　　　case <- w.Quit:
　　　　　　　　return
　　　　　　}
　　　　}
　　}()
}

func (w Worker) Stop() {
　　go func() {
　　　　w.Quit <- true
　　}()
}

type Dispatcher struct {
　　MaxWorkers int
　　WorkerPool chan chan Job
　　Quit chan bool
}

func NewDispatcher(maxWorkers int) *Dispatcher {
　　pool := make(chan chan Job, maxWorkers)
　　return &Dispatcher{MaxWorkers:maxWorkers, WorkerPool:pool, Quit:make(chan bool)}
}

func (d *Dispatcher) Run() {
　　for i:=0; i<d.MaxWorkers; i++ {
　　　　worker := NewWorker(d.WorkerPool)
　　　　worker.Start()
　　}

　　go d.Dispatch()
}

func (d *Dispatcher) Stop() {
　　go func() {
　　　　d.Quit <- true
　　}()
}

func (d *Dispatcher) Dispatch() {
　　for {
　　　　select {
　　　　case job:=<- JobQueue:
　　　　　　go func(job Job) {
　　　　　　　　jobChannel := <- d.WorkerPool
　　　　　　　　jobChannel <- job
　　　　　　}(job)
　　　　case <- d.Quit:
　　　　　　return
　　　　}
　　}
}

func entry(res http.ResponseWriter, req *http.Request) {
　　// fetch job
　　work := Job{serload:Serload{pri:"Just do it"}}
　　JobQueue <- work
　　fmt.Fprintf(res, "Hello World ...again")
}

func init() {
　　runtime.GOMAXPROCS(MaxWorker)
　　JobQueue = make(chan Job, MaxQueue)
　　dispatcher := NewDispatcher(MaxWorker)
　　dispatcher.Run()
}

func main() {
　　Port := "8086"
　　IsHttp := true
　　arg_num := len(os.Args)
　　if 2<=arg_num {
　　　　Port = os.Args[1]
　　}
　　if 3<=arg_num {
　　　　if os.Args[2]=="true" {
　　　　　　IsHttp = true
　　　　} else {
　　　　　　IsHttp = false
　　　　}
　　}
　　fmt.Printf("server is http %t\n", IsHttp)
　　fmt.Println("server listens at ", Port)

　　http.HandleFunc("/", entry)

　　var err error
　　if IsHttp {
　　　　err = http.ListenAndServe(":"+Port, nil)
　　} else {
　　　　err = http.ListenAndServeTLS(":"+Port, "server.crt", "server.key", nil)
　　}
　　if err != nil {
　　　　fmt.Println("Server failure /// ", err)
　　}

　　fmt.Println("quit")
}