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

多高？

很高！

到底多高？

没有一亿，都算少了！

.

.

.

然后就没有然后了。。。

“段子 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")
}

//结果

Finally:

为了避免大家陷入困境，我只给大家指出思路，这样就不会引导大家进入似懂非懂的怪圈

1. 协程池里的协程数目应该与CPU内核数一致，这个好理解，这时候效率和利用率都是最高的

2. 每个协程运行一个工作者出来处理客户端请求（我们就是简单的打印出“Just do it”而已，不在于复杂度，在于处理流程）

好吧，再简单讲讲代码

首先，请自己去学习：Go的协程和渠道（文字概念可以去看书，例子，我之前的博文都有涉及，保证都是可运行的例子）

这个demo的核心：

1. 工作者工作协程，挂入调度器，取Job，执行Job，周而复始

2. 调度器，从Job队列取Job，分配给工作者，周而复始

3. web响应里，模拟了客户的请求-Job，并将此Job放入Job队列，只有有客户端请求，就周而复始的工作

好了，真的好了

师傅领进门，修行在个人

哈哈，我是教"孙悟空"的导师！，哈哈哈哈哈

祝你Go的快，Go的好，Go的高

关于Go，大概真的只能到这里啦，天下没有不散的宴席，就到这儿吧

祝，顺利！！！！！