go-channel处理高并发请求

Posted 2020-11-24 0pandas0

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了go-channel处理高并发请求相关的知识，希望对你有一定的参考价值。

go-channel处理高并发请求

go-channel处理高并发请求

最近看了一篇文章讲解怎样使用go-channel的，周末就花了点时间学习了一下，文章原文地址：

http://marcio.io/2015/07/handling-1-million-requests-per-minute-with-golang/ ，然后自己进行了一个简单的性能测试。

一、Channel简介

下面是go by example中的一个简单的channel使用的例子：

package main
import "fmt"
func main() {
    messages := make(chan string)
    go func() { messages <- "ping" }()
    msg := <-messages
    fmt.Println(msg)
}

通道是连接多个 Go 协程的管道。你可以从一个 Go 协程将值发送到通道，然后在别的 Go 协程中接收。使用 make(chan val-type) 创建一个新的通道。通道类型就是他们需要传递值的类型。使用 channel <- 语法发送一个新的值到通道中。这里我们在一个新的 Go 协程中发送 "ping" 到上面创建的messages 通道中。使用 <-channel 语法从通道中接收一个值。这里将接收我们在上面发送的 "ping" 消息并打印出来。我们运行程序时，通过通道，消息 "ping" 成功的从一个 Go 协程传到另一个中。

$ go run channels.go
ping

默认发送和接收操作是阻塞的，直到发送方和接收方都准备完毕。这个特性允许我们，不使用任何其它的同步操作，来在程序结尾等待消息 "ping"。channel也有带缓冲的可以不阻塞直接写到缓冲去（在缓冲没有满的情况下）。更多例子请参考： https://books.studygolang.com/gobyexample/channels/

二、处理包并发请求

上面那篇作者写的分钟处理百万请求文章，代码摘抄了一部分进行分析。下面是关键的几个数据结构：

任务，用来需要表示一个需要处理的逻辑

// Job代表一个任务，根据自己需求定义
type Job struct {
    Id      string
    Payload string
}

worker，用来处理任务的实例

// Worker用来处理job的实例
type Worker struct {
    WorkerPool chan chan Job //需要注册到的worker池
    JobChannel chan Job      //用来接受任务的通道
    quit       chan bool
}

Dispatcher, 用来分发job的实例

type Dispatcher struct { 
    WorkerPool chan chan Job //用来注册worker的池   
    MaxWorkers int           //worker最大个数
 }

初始化逻辑

func NewDispatcher(maxWorkers int) *Dispatcher {
    pool := make(chan chan Job, maxWorkers)
    return &Dispatcher{
        WorkerPool: pool, //初始化worker池
        MaxWorkers: maxWorkers,
    }
}

func (d *Dispatcher) Run() {
    for i := 0; i < d.MaxWorkers; i++ {
        //对每一个worker进行初始化，也就是将worker注册到池中，更直接点就是将每个worker的jobChannel放入到池中
        worker := NewWorker(d.WorkerPool)
        worker.Start()
    }
    go d.dispatch()
}

func NewWorker(workerPool chan chan Job) *Worker {
    return &Worker{
        WorkerPool: workerPool,
        JobChannel: make(chan Job),
        quit:       make(chan bool),
    }
}

//Start函数，启一个goroutine， 启动的时候将自己注册到worker池当中，然后就等待job被放到自己的jobChannel中
//一旦jobChannel中有job放入的时候，就开始处理这个job
//同时加入了一个quit channel可以用来控制销毁这个worker
func (w *Worker) Start() {
    go func() {
        for {
            w.WorkerPool <- w.JobChannel //注册当前这个worker到worker池中，
            // 也就是将自己的jobChannel放入到池中，用来接收job
            select {
            case job := <-w.JobChannel:
                //channel中放入了一个job
                if _, err := job.Done(); err != nil {
                    //处理这个job
                }
            case <-w.quit:
                // 收到停止的信号，销毁这个worker
                return
            }
        }
    }()
}

任务分发逻辑

func (d *Dispatcher) dispatch() {
    for {
        select {
        case job := <-JobQueue:
            // 收到一个job
            go func(job Job) {
                // 从worker池中，选取一个worker的jobChannel，如果worker池中是空的，则会阻塞在这里
                jobChannel := <-d.WorkerPool
                // 将job放入到其中一个worker的jobChannel中，等待这个worker进行处理
                jobChannel <- job
            }(job)
        }
    }
}

三、测试

1、测试工具

ab，下载地址： https://www.apachehaus.com/cgi-bin/download.plx

2、测试结果

$ ./abs -n 100000 -c 1000 "http://127.0.0.1:8080/job"
This is ApacheBench, Version 2.3 <$Revision: 1843412 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 127.0.0.1 (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:
Server Hostname:        127.0.0.1
Server Port:            8080

Document Path:          /job
Document Length:        0 bytes

Concurrency Level:      1000
Time taken for tests:   51.913 seconds
Complete requests:      100000
Failed requests:        1
   (Connect: 1, Receive: 0, Length: 0, Exceptions: 0)
Total transferred:      7500000 bytes
html transferred:       0 bytes
Requests per second:    1926.28 [#/sec] (mean)
Time per request:       519.134 [ms] (mean)
Time per request:       0.519 [ms] (mean, across all concurrent requests)
Transfer rate:          141.09 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   7.2      0    1007
Processing:    58  497 187.4    429    1448
Waiting:        6  348 195.3    315    1113
Total:         58  497 187.5    430    1449

Percentage of the requests served within a certain time (ms)
  50%    430
  66%    435
  75%    441
  80%    446
  90%    901
  95%    970
  98%   1014
  99%   1076
 100%   1449 (longest request)

测试结果感觉有点不太理想，不知道是不是因为电脑性能的原因还是参数设置的问题。在不用go-channel的测试和这个性能差不多，大家可以把这个代码下载下来自己测试一下，比对一下结果看看有没有优化的空间。

完整代码下载地址： https://gitee.com/ncuzhangben/GoStudy/tree/master/go-channel

以上是关于go-channel处理高并发请求的主要内容，如果未能解决你的问题，请参考以下文章