Golang 中那些隐秘的角落

packagemainimport (
"fmt")
funcconcurrentMapWrite() {
deferfunc() {
iferr :=recover(); err!=nil {
fmt.Printf("Panic occurred due to %+v, Recovered in f", err)
        }
    }()
m :=map[int]int{}
idx :=0for {
gofunc() {
m[idx] =1        }()
idx++    }
}
funcmain() {
concurrentMapWrite()
}

funcdiv(x, yint) int {
returnx/y}
funcf() {
deferfunc() {
iferr :=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.funcmapassign(t*maptype, h*hmap, keyunsafe.Pointer) unsafe.Pointer {
ifh==nil {
panic(plainError("assignment to entry in nil map"))
    }
// 省略 ...ifh.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^=hashWritingifh.buckets==nil {
h.buckets=newobject(t.bucket) // newarray(t.bucket, 1)    }
again:
// 省略 ...bucketloop:
// 省略 ...done:
ifh.flags&hashWriting==0 {
fatal("concurrent map writes")
    }
h.flags&^=hashWritingift.indirectelem() {
elem=*((*unsafe.Pointer)(elem))
    }
returnelem}

// 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:nosplitfuncfatal(sstring) {
// 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:nosplitfuncfatalthrow(tthrowType) {
pc :=getcallerpc()
sp :=getcallersp()
gp :=getg()
ifgp.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()
ifdopanic_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}

packagemainimport (
"fmt")
funcappendSliceWithinCap(s []string) {
s=append(s, "two")
s[0] ="appendSliceWithinCap"}
funcappendSliceOverCap(s []string) {
s=append(s, "two")
s=append(s, "three")
s[0] ="appendSliceOverCap"}
funcmain() {
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"]}

typeslicestruct {
arrayunsafe.Pointer// 指向底层数组的指针lenint// 切片的长度capint// 切片的容量}

// 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).funcgrowslice(oldPtrunsafe.Pointer, newLen, oldCap, numint, et*_type) slice {
oldLen :=newLen-num// 省略 ...newcap :=oldCapdoublecap :=newcap+newcapifnewLen>doublecap {
newcap=newLen    } else {
constthreshold=256ifoldCap<threshold {
newcap=doublecap        } else {
// Check 0 < newcap to detect overflow// and prevent an infinite loop.for0<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.ifnewcap<=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")// }ifoverflow||capmem>maxAlloc {
panic(errorString("growslice: len out of range"))
    }
varpunsafe.Pointerifet.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)
iflenmem>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)
returnslice{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(ctxcontext.Context, callHdr*CallHdr) (_*Stream, errerror) {
// 省略 ...// 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"})
ifcallHdr.SendCompress!="" {
t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-encoding", Value: callHdr.SendCompress})
    }
ifdl, 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, handlefunc(*Stream)) (closebool) {
buf :=newRecvBuffer()
s :=&Stream{
id:  frame.Header().StreamID,
st:  t,
buf: buf,
fc:  &inFlow{limit: initialWindowSize},
    }
varstatedecodeStatefor_, hf :=rangeframe.Fields {
state.processHeaderField(hf)
    }
// 省略 ...s.recvCompress=state.encodingifstate.timeoutSet {
s.ctx, s.cancel=context.WithTimeout(context.TODO(), state.timeout)
    } else {
s.ctx, s.cancel=context.WithCancel(context.TODO())
    }
// 省略 ...}
func (d*decodeState) processHeaderField(fhpack.HeaderField) {
switchf.Name {
// 省略 ...case"grpc-timeout":
d.timeoutSet=truevarerrerrord.timeout, err=decodeTimeout(f.Value)
iferr!=nil {
d.setErr(streamErrorf(codes.Internal, "transport: malformed time-out: %v", err))
return        }
// 省略 ...    }
}