一个调度系统的开发与性能优化

setFuncs := []func(){
    func() { b.set1(dbCache, errMessageChannel) },
    func() { b.set2(syncCache, ids, errMessageChannel) },
    func() { b.set3(syncCache, ids, errMessageChannel) },
    func() { b.set4(ids, errMessageChannel) },
    func() { b.set5(ids, errMessageChannel) },
    func() { b.set6(ids, errMessageChannel) },
    func() { b.set7(ids, errMessageChannel) },
    func() { b.set8(errMessageChannel) },
    func() { b.set9(ids, errMessageChannel) },
    func() { b.set10(errMessageChannel) },
    func() { b.set11(ids, errMessageChannel) },
    func() { b.set12(errMessageChannel) },}

type WaitGroupWrapper struct {
  gosync.WaitGroup}func (w *WaitGroupWrapper) Wrap(cb func()) {
  w.Add(1)
  go func() {
    cb()
    w.Done()
  }()}

for _, f := range setFuncs {
    wg.Wrap(f)
  }
  wg.Wait()

1: 67108864 [2: 134217728] @ 0x49b4a7 0x49b3e1 0x57887c 0x57895e 0x137dbbb 0x138035d 0x138029f 0x138cc6a 0x138e1c0 0x1341c8b 0x139073c 0x1341526 0x1340e2c 0x1341f7a 0x7fb3fe 0x7fb0cd 0x7faffd 0x45c291
# 0x49b4a6  bytes.makeSlice+0x76                      /usr/local/Cellar/go/1.9.2/libexec/src/bytes/buffer.go:231
# 0x49b3e0  bytes.(*Buffer).ReadFrom+0x290                    /usr/local/Cellar/go/1.9.2/libexec/src/bytes/buffer.go:203
# 0x57887b  io/ioutil.readAll+0x12b                     /usr/local/Cellar/go/1.9.2/libexec/src/io/ioutil/ioutil.go:33
# 0x57895d  io/ioutil.ReadAll+0x3d                      /usr/local/Cellar/go/1.9.2/libexec/src/io/ioutil/ioutil.go:42

respData, err := ioutil.ReadAll(resp.Body)  
    err = json.NewDecoder(resp.Body).Decode(&reqData.RespValue)
    if err != nil {
        err = errors.Newf(err, "failed reading the response body")  
        return    
    }
    
    if len(respData) > 0 {    
      if reqData.RespValue != nil {   
          err = json.Unmarshal(respData, &reqData.RespValue)    
          if err != nil {   
              err = errors.Newf(err, "failed unmarshaling the response body: %s", respData)   
          }   
      }
    }

// readAll reads from r until an error or EOF and returns the data it read// from the internal buffer allocated with a specified capacity.func readAll(r io.Reader, capacity int64) (b []byte, err error) {
  var buf bytes.Buffer
  // If the buffer overflows, we will get bytes.ErrTooLarge.
  // Return that as an error. Any other panic remains.
  defer func() {
    e := recover()
    if e == nil {
      return
    }
    if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
      err = panicErr
    } else {
      panic(e)
    }
  }()
  if int64(int(capacity)) == capacity {
    buf.Grow(int(capacity))
  }
  _, err = buf.ReadFrom(r)
  return buf.Bytes(), err}// ReadAll reads from r until an error or EOF and returns the data it read.// A successful call returns err == nil, not err == EOF. Because ReadAll is// defined to read from src until EOF, it does not treat an EOF from Read// as an error to be reported.func ReadAll(r io.Reader) ([]byte, error) {
  return readAll(r, bytes.MinRead)}

// ReadFrom reads data from r until EOF and appends it to the buffer, growing// the buffer as needed. The return value n is the number of bytes read. Any// error except io.EOF encountered during the read is also returned. If the// buffer becomes too large, ReadFrom will panic with ErrTooLarge.func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
  b.lastRead = opInvalid
  for {
    i := b.grow(MinRead)
    m, e := r.Read(b.buf[i:cap(b.buf)])
    if m < 0 {
      panic(errNegativeRead)
    }

    b.buf = b.buf[:i+m]
    n += int64(m)
    if e == io.EOF {
      return n, nil // e is EOF, so return nil explicitly
    }
    if e != nil {
      return n, e
    }
  }}// grow grows the buffer to guarantee space for n more bytes.// It returns the index where bytes should be written.// If the buffer can't grow it will panic with ErrTooLarge.func (b *Buffer) grow(n int) int {
  m := b.Len()
  // If buffer is empty, reset to recover space.
  if m == 0 && b.off != 0 {
    b.Reset()
  }
  // Try to grow by means of a reslice.
  if i, ok := b.tryGrowByReslice(n); ok {
    return i
  }
  // Check if we can make use of bootstrap array.
  if b.buf == nil && n <= len(b.bootstrap) {
    b.buf = b.bootstrap[:n]
    return 0
  }
  c := cap(b.buf)
  if n <= c/2-m {
    // We can slide things down instead of allocating a new
    // slice. We only need m+n <= c to slide, but
    // we instead let capacity get twice as large so we
    // don't spend all our time copying.
    copy(b.buf, b.buf[b.off:])
  } else if c > maxInt-c-n {
    panic(ErrTooLarge)
  } else {
    // Not enough space anywhere, we need to allocate.
    buf := makeSlice(2*c + n)
    copy(buf, b.buf[b.off:])
    b.buf = buf
  }
  // Restore b.off and len(b.buf).
  b.off = 0
  b.buf = b.buf[:m+n]
  return m}

err = json.NewDecoder(resp.Body).Decode(&reqData.RespValue)if err != nil {
  err = errors.Newf(err, "failed unmarshaling the response body: %v", resp.Body)}