Golang 中那些隐秘的角落

package main
import (    "fmt")
func concurrentMapWrite() {    defer func() {        if err := recover(); err != nil {            fmt.Printf("Panic occurred due to %+v, Recovered in f", err)        }    }()        m := map[int]int{}    idx := 0    for {        go func() {            m[idx] = 1        }()        idx++    }}
func main() {    concurrentMapWrite()}

func div(x, y int) int {  return x / y}func f() {    defer func() {        if err := recover(); err != nil {            fmt.Printf("Panic occurred due to %+v, Recovered in f", err)        }    }()    fmt.Println(div(1, 0))}

// Like mapaccess, but allocates a slot for the key if it is not present in the map.func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {  if h == nil {    panic(plainError("assignment to entry in nil map"))  }  // 省略 ...  if h.flags&hashWriting != 0 {    fatal("concurrent map writes")  }  hash := t.hasher(key, uintptr(h.hash0))  // Set hashWriting after calling t.hasher, since t.hasher may panic,  // in which case we have not actually done a write.  h.flags ^= hashWriting  if h.buckets == nil {    h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)  }again:  // 省略 ...bucketloop:  // 省略 ...done:  if h.flags&hashWriting == 0 {    fatal("concurrent map writes")  }  h.flags &^= hashWriting  if t.indirectelem() {    elem = *((*unsafe.Pointer)(elem))  }  return elem}

// fatal triggers a fatal error that dumps a stack trace and exits.//// fatal is equivalent to throw, but is used when user code is expected to be// at fault for the failure, such as racing map writes.//// fatal does not include runtime frames, system goroutines, or frame metadata// (fp, sp, pc) in the stack trace unless GOTRACEBACK=system or higher.////go:nosplitfunc fatal(s string) {  // Everything fatal does should be recursively nosplit so it  // can be called even when it's unsafe to grow the stack.  systemstack(func() {    print("fatal error: ", s, "\n")  })  fatalthrow(throwTypeUser)}// fatalthrow implements an unrecoverable runtime throw. It freezes the// system, prints stack traces starting from its caller, and terminates the// process.////go:nosplitfunc fatalthrow(t throwType) {  pc := getcallerpc()  sp := getcallersp()  gp := getg()  if gp.m.throwing == throwTypeNone {    gp.m.throwing = t  }  // Switch to the system stack to avoid any stack growth, which may make  // things worse if the runtime is in a bad state.  systemstack(func() {    startpanic_m()    if dopanic_m(gp, pc, sp) {      // crash uses a decent amount of nosplit stack and we're already      // low on stack in throw, so crash on the system stack (unlike      // fatalpanic).      crash()    }    exit(2)  })  *(*int)(nil) = 0 // not reached}

package main

import (  "fmt")func appendSliceWithinCap(s []string) {  s = append(s, "two")  s[0] = "appendSliceWithinCap"}func appendSliceOverCap(s []string) {  s = append(s, "two")  s = append(s, "three")  s[0] = "appendSliceOverCap"}func main() {  fmt.Println("hello main")  s := make([]string, 1, 2)  s[0] = "one"  fmt.Println(s) // ["one"]  appendSliceWithinCap(s)  fmt.Println(s) // ["appendSliceWithinCap"]  appendSliceOverCap(s)  fmt.Println(s) // ["appendSliceWithinCap"]}

type slice struct {  array unsafe.Pointer  // 指向底层数组的指针  len int               // 切片的长度  cap int               // 切片的容量}

// growslice allocates new backing store for a slice.//// arguments:////  oldPtr = pointer to the slice's backing array//  newLen = new length (= oldLen + num)//  oldCap = original slice's capacity.//     num = number of elements being added//      et = element type//// return values:////  newPtr = pointer to the new backing store//  newLen = same value as the argument//  newCap = capacity of the new backing store//// Requires that uint(newLen) > uint(oldCap).// Assumes the original slice length is newLen - num//// A new backing store is allocated with space for at least newLen elements.// Existing entries [0, oldLen) are copied over to the new backing store.// Added entries [oldLen, newLen) are not initialized by growslice// (although for pointer-containing element types, they are zeroed). They// must be initialized by the caller.// Trailing entries [newLen, newCap) are zeroed.//// growslice's odd calling convention makes the generated code that calls// this function simpler. In particular, it accepts and returns the// new length so that the old length is not live (does not need to be// spilled/restored) and the new length is returned (also does not need// to be spilled/restored).func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {  oldLen := newLen - num  // 省略 ...
  newcap := oldCap  doublecap := newcap + newcap  if newLen > doublecap {    newcap = newLen  } else {    const threshold = 256    if oldCap < threshold {      newcap = doublecap    } else {      // Check 0 < newcap to detect overflow      // and prevent an infinite loop.      for 0 < newcap && newcap < newLen {        // Transition from growing 2x for small slices        // to growing 1.25x for large slices. This formula        // gives a smooth-ish transition between the two.        newcap += (newcap + 3*threshold) / 4      }      // Set newcap to the requested cap when      // the newcap calculation overflowed.      if newcap <= 0 {        newcap = newLen      }    }  }  // 省略 ...  // The check of overflow in addition to capmem > maxAlloc is needed  // to prevent an overflow which can be used to trigger a segfault  // on 32bit architectures with this example program:  //  // type T [1<<27 + 1]int64  //  // var d T  // var s []T  //  // func main() {  //   s = append(s, d, d, d, d)  //   print(len(s), "\n")  // }  if overflow || capmem > maxAlloc {    panic(errorString("growslice: len out of range"))  }
  var p unsafe.Pointer  if et.ptrdata == 0 {    p = mallocgc(capmem, nil, false)    // The append() that calls growslice is going to overwrite from oldLen to newLen.    // Only clear the part that will not be overwritten.    // The reflect_growslice() that calls growslice will manually clear    // the region not cleared here.    memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)  } else {    // Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.    p = mallocgc(capmem, et, true)    if lenmem > 0 && writeBarrier.enabled {      // Only shade the pointers in oldPtr since we know the destination slice p      // only contains nil pointers because it has been cleared during alloc.      bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(oldPtr), lenmem-et.size+et.ptrdata)    }  }  memmove(p, oldPtr, lenmem)  return slice{p, newLen, newcap}}

// NewStream 方法的调用链路：grpc.Invoke -> invoke -> sendRequest -> NewStream
// NewStream creates a stream and register it into the transport as "active"// streams.func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) {  // 省略 ...    // HPACK encodes various headers. Note that once WriteField(...) is  // called, the corresponding headers/continuation frame has to be sent  // because hpack.Encoder is stateful.  t.hBuf.Reset()  t.hEnc.WriteField(hpack.HeaderField{Name: ":method", Value: "POST"})  t.hEnc.WriteField(hpack.HeaderField{Name: ":scheme", Value: t.scheme})  t.hEnc.WriteField(hpack.HeaderField{Name: ":path", Value: callHdr.Method})  t.hEnc.WriteField(hpack.HeaderField{Name: ":authority", Value: callHdr.Host})  t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})  t.hEnc.WriteField(hpack.HeaderField{Name: "user-agent", Value: t.userAgent})  t.hEnc.WriteField(hpack.HeaderField{Name: "te", Value: "trailers"})
  if callHdr.SendCompress != "" {    t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: callHdr.SendCompress})  }  if dl, ok := ctx.Deadline(); ok {    // Send out timeout regardless its value. The server can detect timeout context by itself.    timeout := dl.Sub(time.Now())    t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-timeout", Value: encodeTimeout(timeout)})  }  // 省略 ...}

// processHeaderField 方法调用链：grpc.Server -> handleRawConn -> serveNewHTTP2Transport -> serveStreams -> HandleStreams -> operateHeaders -> processHeaderField// operateHeader takes action on the decoded headers.func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame, handle func(*Stream)) (close bool) {  buf := newRecvBuffer()  s := &Stream{    id:  frame.Header().StreamID,    st:  t,    buf: buf,    fc:  &inFlow{limit: initialWindowSize},  }  var state decodeState  for _, hf := range frame.Fields {    state.processHeaderField(hf)  }  // 省略 ...  s.recvCompress = state.encoding  if state.timeoutSet {    s.ctx, s.cancel = context.WithTimeout(context.TODO(), state.timeout)  } else {    s.ctx, s.cancel = context.WithCancel(context.TODO())  }  // 省略 ...}func (d *decodeState) processHeaderField(f hpack.HeaderField) {  switch f.Name {  // 省略 ...  case "grpc-timeout":    d.timeoutSet = true    var err error    d.timeout, err = decodeTimeout(f.Value)    if err != nil {      d.setErr(streamErrorf(codes.Internal, "transport: malformed time-out: %v", err))      return    }  // 省略 ...  }}