当我的goroutine数量很大时，代码会出错

Golang小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《当我的goroutine数量很大时，代码会出错》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

我的代码在少量 goroutine 下工作正常，但在内存和指针上会出现大量错误。我猜是我的锁使用不当。你能帮我看看我写的工具吗？调试了好久却无从下手。

我想过给时钟函数加个读锁。但是还是会报错。我也尝试过使用sync.map。但并没有解决问题

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "encoding/json"
    "strings"
    "sync"
    "time"
    "strconv"
)

type urlarray struct {
    url string `json:"url"`
    method string `json:"method"`
    params string `json:"params"`
}
type msgrequest struct {
    command string `json:"command"`
    concurrent int `json:"concurrent"`
    incrementalratio float64 `json:"incrementalratio"`
    initialratio float64 `json:"initialratio"`
    intervals int `json:"intervals"`
    urlarray []urlarray `json:"urls"`
}
type groupdata struct {
    totalcount int `json:"totalcount"`
    failcount int `json:"failcount"`
    successrate float64 `json:"successrate"`
    costtime float64 `json:"costtime"`
    avergetime float64 `json:"avergetime"`
}
type msgresponse struct {
    timeobject map[string]groupdata `json:"timeobject"`
    totalcount int `json:"totalcount"`
    failcount int `json:"failcount"`
    successrate float64 `json:"successrate"`
    costtime float64 `json:"costtime"`
    avergetime float64 `json:"avergetime"`
}
type leveldata struct {
    result map[string]groupdata
    sync.rwmutex
}
type resultstatic struct {
    result map[string]msgresponse 
}

var p = fmt.println
var leveloutput leveldata
var output resultstatic
var closeallchan chan int
var ishandle = false


//write to map
func (r *leveldata) recordstatic(url string, status bool, usetimesec float64) {
    r.lock()
    defer r.unlock()
    val, ok := r.result[url]
    if ok {
        val.totalcount += 1
        val.costtime += usetimesec
        if status == false {
            val.failcount += 1
        }
        val.successrate = 1.00 - (float64(val.failcount) * 1.00) / (float64(val.totalcount) * 1.00) 
        val.avergetime = val.costtime / float64(val.totalcount)
        leveloutput.result[url] = val
        } else {
            failcnt := 0
            if status == false {
                failcnt = 1
            }
            successrate := float64(1 - failcnt)
            val := groupdata{totalcount: 1, failcount: failcnt, successrate: successrate, costtime: usetimesec, avergetime: usetimesec}
            leveloutput.result[url] = val
        }
}

//get request
func get(url string, params string) {
    start := time.now()
    data := url + "?" + params
    response, err:= http.get(data)
    end := time.now()
    costtime := float64((end.sub(start)).seconds())

    if err != nil {
        leveloutput.recordstatic(url, false, costtime)
    } else {
        leveloutput.recordstatic(url, true, costtime)
    }

    defer response.body.close()
}   

// post request
func post(url string, params string) {
    start := time.now()
    response, err := http.post(url, "application/x-www-form-urlencoded", strings.newreader(params))
    end := time.now()
    costtime := float64((end.sub(start)).seconds())

    if err != nil {
        leveloutput.recordstatic(url, false, costtime)
    } else {
        leveloutput.recordstatic(url, true, costtime)
    }

    response.body.close()
}

//clock ticker
func (r *leveldata) clock(urlarrays []urlarray, concurrent int, initialratio float64, incrementalratio float64, intervals int) {
    start := int(float64(concurrent) * initialratio)
    increment := int(float64(concurrent) * incrementalratio)
    ticker := time.newticker(time.duration(intervals) * time.second)
    endtotal := increment + concurrent
    objectkey := 0

    for range ticker.c {
        select {
        case <-closeallchan:
            p("死循环退出")
            return 
        default:
            if objectkey != 0 {
                for _, v := range(urlarrays) {
                    val1, ok1 := output.result[v.url]
                    p(val1, ok1)
                    if !ok1 {
                        val1 = msgresponse{}
                        val1.timeobject = make(map[string]groupdata)
                    }
                    val1.timeobject[strconv.itoa(objectkey)] = leveloutput.result[v.url]

                    val1.totalcount += (val1.timeobject[strconv.itoa(objectkey)]).totalcount
                    val1.failcount += (val1.timeobject[strconv.itoa(objectkey)]).failcount
                    val1.costtime += (val1.timeobject[strconv.itoa(objectkey)]).costtime
                    val1.successrate = 1.00 - (float64(val1.failcount) * 1.00) / (float64(val1.totalcount) * 1.00) 
                    val1.avergetime = val1.costtime / float64(val1.totalcount)
                    output.result[v.url] = val1
                }
            } 

            leveloutput = leveldata{result: map[string]groupdata{}}

            if start >= endtotal {
                p("start == concurrent")
                close(closeallchan)
                time.sleep(time.second)
                return
            }

            if objectkey == 0 {
                for i := 0; i < start; i++ {
                    go work(urlarrays)
                }
            } else {
                for i := 0; i < increment; i++ {
                    go work(urlarrays)
                }
            }

            objectkey += 1
            start += increment
        }
    }
}

//work
func work(urlarrays []urlarray) {
    i := 0
    for {
        select {
        case <-closeallchan:
            return 
        default:
            index := i % len(urlarrays)
            i++

            url := urlarrays[index].url
            method := urlarrays[index].method
            params := urlarrays[index].params

            if method == "get" {
                get(url, params)
            } else {
                post(url, params)
            } 
        }
    }
} 

func setupresponse(w *http.responsewriter, req *http.request) {
    (*w).header().set("access-control-allow-origin", "*")
    (*w).header().set("access-control-allow-methods", "post, get, options")
    (*w).header().set("access-control-allow-headers", "accept, content-type, content-length, accept-encoding, x-csrf-token, authorization")
}


func myfunc(w http.responsewriter, r *http.request) {
    setupresponse(&w, r)
    if (r).method == "options" {
        return
    }

    b, err := ioutil.readall(r.body)
    defer r.body.close()
    if err != nil {
        http.error(w, err.error(), 501)
        return 
    }
    //json decode
    var msgs msgrequest
    err = json.unmarshal(b, &msgs)
    if err != nil {
        p(err.error())
        http.error(w, err.error(), 502)
        return
    }

    var command = msgs.command

    if command == "stop" {
        p("stop start")
        if ishandle {
            close(closeallchan)
            ishandle = false 
        } else {
            p("no handle")
            http.error(w, "未有数据在执行", 504)
            return
        }
    } else if command == "get" {
        p("get start")
        if ishandle {
            p(output.result)
            js, err := json.marshal(output.result)
            if err != nil {
                http.error(w, err.error(), 503)
                return
            }
            w.header().set("content-type", "application/json")
            w.write(js)
        } else {
            p("no handle")
            http.error(w, "未有数据在执行", 504)
            return
        }
    } else {
        ishandle = true
        closeallchan = make(chan int)
        output = resultstatic{result: map[string]msgresponse{}}
        urlarrays := msgs.urlarray
        concurrent := msgs.concurrent
        initialratio := msgs.initialratio
        incrementalratio := msgs.incrementalratio
        intervals := msgs.intervals
        leveloutput.clock(urlarrays, concurrent, initialratio, incrementalratio, intervals)
        ishandle = false
        js, err := json.marshal(output.result)
        if err != nil {
            http.error(w, err.error(), 503)
            return 
        }
        p(output.result)

        w.header().set("content-type", "application/json")
        w.write(js) 
    }
    return
}

func main() {
    http.handlefunc("/handle", myfunc)
    err := http.listenandserve(":8080", nil)
    if err != nil {
        panic(err)
    }
}


// json example
// {
//  "command": "handle/get/stop",
//  "concurrent": 100,
//  "initialratio": 0.60,
//  "incrementalratio": 0.20,
//  "intervals": 10,
//  "urls": [
//      {
//          "url": "http://google.com",
//          "method": "get",
//          "params": ""    
//      }
//  ]
// }

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x40 pc=0x6782c4]

goroutine 64655 [running]:
main.post(0xc00001e0c0, 0x3c, 0xc000188510, 0x2f)
    /root/toolv2.go:114 +0x1b4
main.work(0xc000391380, 0x1, 0x4)
    /root/toolv2.go:193 +0xcf
created by main.(*LevelData).clock
    /root/toolv2.go:161 +0x657
exit status 2

解决方案

“无效的内存地址或零指针取消引用”并不表示存在数据争用。您正在取消引用一个为零的指针：

func post(url string, params string) {
    start := time.Now()
    response, err := http.Post(url, "application/x-www-form-urlencoded", strings.NewReader(params))
    end := time.Now()
    costTime := float64((end.Sub(start)).Seconds())

    if err != nil {
        levelOutput.recordStatic(url, false, costTime)
    } else {
        levelOutput.recordStatic(url, true, costTime)
    }

    response.Body.Close()
}

发生错误后不得取消引用响应，因为此时响应为零。

理论要掌握，实操不能落！以上关于《当我的goroutine数量很大时，代码会出错》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！