func getTarget(nums []int, target int) int {
left := 0
right := len(nums) - 1
for left <= right {
mid := left + (right-left)>>2
if nums[mid] == target {
return mid
} else if nums[mid] > target {
right = mid - 1
} else {
left = mid + 1
}
}
return -1
}

func getFirstTarget(nums []int, target int) int {
left := 0
right := len(nums) - 1
for left <= right {
mid := left + (right-left)>>2
if nums[mid] >= target {
right = mid - 1
} else {
left = mid + 1
}
}
return left
}

func getLastTarget(nums []int, target int) int {
left := 0
right := len(nums) - 1
for left <= right {
mid := left + (right-left)>>2
if nums[mid] <= target {
      left = mid + 1
} else {
right = mid - 1
}
}
return right
}

func getFirstLargerTarget(nums []int, target int) int {
left := 0
right := len(nums) - 1
for left <= right {
mid := left + (right-left)>>2
if nums[mid] > target {
if mid == 0 || nums[mid-1] <= target {
// mid == 0 所有值都比target大
// nums[mid-1] <= target 说明mid是第一个比目标值大的索引
return mid
} else {
right = mid - 1
}
} else if nums[mid] <= target {
left = mid + 1
}
}
//所有元素都小于目标元素
return -1
}

func getLastSmall(nums []int, target int) int {
left := 0
right := len(nums) - 1
for left <= right {
mid := left + (right-left)>>2
if nums[mid] >= target {
right = mid - 1
} else nums[mid] < target {
if mid == len(nums)-1 || nums[mid+1] >= target {
// mid == len(nums)-1 所有元素都小于目标元素
// nums[mid+1] >= target mid是最后一个小于目标元素的索引
return mid
}
left = mid + 1
}
}
//所有元素都大于目标元素
return -1
}

// [5,6,7,1,2,3]
func getTargetInLoop(nums []int, target int) int {
left := 0
right := len(nums) - 1

for left <= right {
mid := left + (right-left)>>1
if nums[mid] == target {
return mid
}
if nums[left] <= nums[mid] { // left和right相差1时，mid=left
// 说明 left和mid在同一个有序数组里
if target >= nums[left] && target < nums[mid] {
// 说明 target 在 left和mid中间 需要移动right
right = mid - 1
}else {
// target 和 (left/mid)不在同一个有序数组
left = mid + 1
}
} else {
// 说明 mid和right在同一个有序数组里
if nums[mid] < target && nums[right] >= target {
// 说明 target 在mid和right中间 需要移动left
left = mid + 1
}else{
// target 和 (mid/right)不在同一个有序数组
right = mid - 1
}
}
}
return -1
}

func getTargetInTwoDimensional(nums [][]int, target int) bool {
line := len(nums)
  if line == 0 {
    return false
  }
col := len(nums[0])

left := 0
right := line*col - 1
for left <= right {
mid := left + (right-left)>>2
x := mid / col
y := mid % col
if nums[x][y] == target {
return true
} else if nums[x][y] > target {
right = mid - 1
} else {
left = mid + 1
}
}
return false
}

writePointer(slot, ptr):
    shade(ptr)
    *slot = ptr

writePointer(slot, ptr)
    shade(*slot)
    *slot = ptr

writePointer(slot, ptr):
    shade(*slot)
    shade(ptr)
    *slot = ptr

type DeltaFIFO struct {
  ...
  queue []string  // 存储的是key,资源对象通过KeyOf生成key，key与资源对象对应
  items map[string]Deltas // map的key就是queue中的元素
}

type Deltas []Delta // Delta 保存的是资源对象以及操作类型 Deltas中每个资源的操作类型都不同(去重)

type Indexers map[string]IndexFunc
type IndexFunc func(obj interface{}) ([]string, error)
type Indices map[string]Index
type Index map[string]sets.String

func (c *threadSafeMap) ByIndex(indexName, indexKey string) ([]interface(),error)
{
  ...
  indexFunc := c.indexers[indexName] // 根据索引器名称得到索引器函数
  ... // 执行该函数

  index := c.indices[indexName] // 根据索引器名称从indices中获取index
  set := index[indexKey] // 根据查询的key得到查询的结果
  ...
}

func Open(driverName, dataSourceName string) (*DB, error) {
// 查找已注册的驱动 由_ "github.com/go-sql-driver/mysql"提供
  // 驱动是真正和数据库打交道的
  driversMu.RLock()
driveri, ok := drivers[driverName]
driversMu.RUnlock()
if !ok {
return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
}
  
  

if driverCtx, ok := driveri.(driver.DriverContext); ok {
    // 获取连接器
connector, err := driverCtx.OpenConnector(dataSourceName)
if err != nil {
return nil, err
}
return OpenDB(connector), nil
}

return OpenDB(dsnConnector{dsn: dataSourceName, driver: driveri}), nil
}


// OpenDB may just validate its arguments without creating a connection
// to the database. To verify that the data source name is valid, call
// Ping.
func OpenDB(c driver.Connector) *DB {
  // 初始化数据，为后续维护连接池做准备
ctx, cancel := context.WithCancel(context.Background())
db := &DB{
connector:    c,
openerCh:     make(chan struct{}, connectionRequestQueueSize),
lastPut:      make(map[*driverConn]string),
connRequests: make(map[uint64]chan connRequest),
stop:         cancel,
}

go db.connectionOpener(ctx)

return db
}

// Runs in a separate goroutine, opens new connections when requested.
func (db *DB) connectionOpener(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case <-db.openerCh:
      // 收到创建新的连接的请求
db.openNewConnection(ctx)
}
}
}

func (db *DB) Begin() (*Tx, error) {
return db.BeginTx(context.Background(), nil)
}


func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) {
var tx *Tx
var err error
var isBadConn bool
  // 重试策略
for i := 0; i < maxBadConnRetries; i++ {
    // cachedOrNewConn 获取连接池的连接，如果没有，
    // 在连接没有到达设置的最大值时，就创建一个新的连接, 否则只能等待。
    //  inUse=true
tx, err = db.begin(ctx, opts, cachedOrNewConn)
isBadConn = errors.Is(err, driver.ErrBadConn)
if !isBadConn {
break
}
}
if isBadConn {
return db.begin(ctx, opts, alwaysNewConn)
}
return tx, err
}

func (db *DB) begin(ctx context.Context, opts *TxOptions, strategy connReuseStrategy) (tx *Tx, err error) {
dc, err := db.conn(ctx, strategy)
if err != nil {
return nil, err
}
  // releaseConn释放连接时调用,放入连接池 inUse=false
return db.beginDC(ctx, dc, dc.releaseConn, opts)
}

func (db *DB) begin(ctx context.Context, opts *TxOptions, strategy connReuseStrategy) (tx *Tx, err error) {
  // 根据策略获取到了dc
dc, err := db.conn(ctx, strategy)
if err != nil {
return nil, err
}
  // 传入dc
return db.beginDC(ctx, dc, dc.releaseConn, opts)
}


// beginDC starts a transaction. The provided dc must be valid and ready to use.
func (db *DB) beginDC(ctx context.Context, dc *driverConn, release func(error), opts *TxOptions) (tx *Tx, err error) {
var txi driver.Tx
keepConnOnRollback := false
withLock(dc, func() {
_, hasSessionResetter := dc.ci.(driver.SessionResetter)
_, hasConnectionValidator := dc.ci.(driver.Validator)
keepConnOnRollback = hasSessionResetter && hasConnectionValidator
    // dc.ci就是驱动与数据库建立连接的原始结构,通过它开启事务，返回事务的原始结构
txi, err = ctxDriverBegin(ctx, opts, dc.ci)
})
if err != nil {
release(err)
return nil, err
}

// Schedule the transaction to rollback when the context is canceled.
// The cancel function in Tx will be called after done is set to true.
  // 生成一个cancel Contxt，这个context伴随着这个事务，它的生命周期和事务一样长
ctx, cancel := context.WithCancel(ctx)
tx = &Tx{
db:                 db,
dc:                 dc,
releaseConn:        release,
txi:                txi,
cancel:             cancel,
keepConnOnRollback: keepConnOnRollback,
ctx:                ctx,
}
  
  // 等待事务结束
go tx.awaitDone()
return tx, nil
}


// awaitDone blocks until the context in Tx is canceled and rolls back
// the transaction if it's not already done.
func (tx *Tx) awaitDone() {
// Wait for either the transaction to be committed or rolled
// back, or for the associated context to be closed.
  // 等待context的结束
  // 在执行tx.Commit()或tx.RollBack()时，会调用cancel()
<-tx.ctx.Done()

discardConnection := !tx.keepConnOnRollback
  // 如果不是由Commit或RollBack调用的cancel(),导致ctx结束，那么回滚会在这执行
tx.rollback(discardConnection)
}

// Commit commits the transaction.
func (tx *Tx) Commit() error {
   // Check context first to avoid transaction leak.
   // If put it behind tx.done CompareAndSwap statement, we can't ensure
   // the consistency between tx.done and the real COMMIT operation.
   select {
   default:
   // 如果没有调用rollback以及ctx没有结束，那么会走到这
   case <-tx.ctx.Done():
      if atomic.LoadInt32(&tx.done) == 1 {
         return ErrTxDone
      }
      return tx.ctx.Err()
   }
  
  // 原子操作,0->1,rollback时也会做这个操作，确保只执行一次
   if !atomic.CompareAndSwapInt32(&tx.done, 0, 1) {
      return ErrTxDone
   }

   // Cancel the Tx to release any active R-closemu locks.
   // This is safe to do because tx.done has already transitioned
   // from 0 to 1. Hold the W-closemu lock prior to rollback
   // to ensure no other connection has an active query.
   tx.cancel() // 执行cancel方法，结束开始事务时开启的goroutine
   tx.closemu.Lock()
   tx.closemu.Unlock()

   var err error
   // 通过驱动建立的连接执行commit方法
   withLock(tx.dc, func() {
      err = tx.txi.Commit()
   })
   if !errors.Is(err, driver.ErrBadConn) {
      tx.closePrepared()
   }
   // 释放连接 inUse=false
   tx.close(err)
   return err
}

// Rollback aborts the transaction.
func (tx *Tx) Rollback() error {
return tx.rollback(false)
}


// rollback aborts the transaction and optionally forces the pool to discard
// the connection.
func (tx *Tx) rollback(discardConn bool) error {
  // 原子操作 确保只执行一次
if !atomic.CompareAndSwapInt32(&tx.done, 0, 1) {
return ErrTxDone
}

if rollbackHook != nil {
rollbackHook()
}

// Cancel the Tx to release any active R-closemu locks.
// This is safe to do because tx.done has already transitioned
// from 0 to 1. Hold the W-closemu lock prior to rollback
// to ensure no other connection has an active query.
tx.cancel()
tx.closemu.Lock()
tx.closemu.Unlock()

var err error
  // 通过驱动建立的连接执行rollback方法
withLock(tx.dc, func() {
err = tx.txi.Rollback()
})
if !errors.Is(err, driver.ErrBadConn) {
tx.closePrepared()
}
if discardConn {
err = driver.ErrBadConn
}
  // 释放连接
tx.close(err)
return err
}

// gorm 连接数据库
func Open(dialector Dialector, opts ...Option) (db *DB, err error) {
  // 全局配置
  config := &Config{}

...

  // 加载配置
for _, opt := range opts {
if opt != nil {
if applyErr := opt.Apply(config); applyErr != nil {
return nil, applyErr
}
defer func(opt Option) {
if errr := opt.AfterInitialize(db); errr != nil {
err = errr
}
}(opt)
}
}

  // 时间精度配置 默认毫秒
if d, ok := dialector.(interface{ Apply(*Config) error }); ok {
if err = d.Apply(config); err != nil {
return
}
}


  // 注册query/create..等操作执行时所需要调用的函数
  // gorm:query -> gorm:preload -> gorm:after_query
  // 对不同版本的数据库做相应的约束配置
  // 调用sql.Open()初始化连接池
db.callbacks = initializeCallbacks(db)
if config.Dialector != nil {
err = config.Dialector.Initialize(db)
}

  ...

  // clone=1
db = &DB{Config: config, clone: 1}

// 在执行sql前后，相关的信息都会存在其中
db.Statement = &Statement{
DB:       db,
ConnPool: db.ConnPool,
Context:  context.Background(),
Clauses:  map[string]clause.Clause{},
}

  // 连接时，自动会进行ping操作
if err == nil && !config.DisableAutomaticPing {
if pinger, ok := db.ConnPool.(interface{ Ping() error }); ok {
err = pinger.Ping()
}
}

if err != nil {
config.Logger.Error(context.Background(), "failed to initialize database, got error %v", err)
}

return
}

// Session create new db session 可覆盖全局配置
func (db *DB) Session(config *Session) *DB {
var (
txConfig = *db.Config
tx       = &DB{
Config:    &txConfig,
Statement: db.Statement, // 直接赋值原db的statement
Error:     db.Error,
clone:     1, // clone = 1
}
)

  // 对全局配置进行覆盖
if config.CreateBatchSize > 0 {
tx.Config.CreateBatchSize = config.CreateBatchSize
}

if config.SkipDefaultTransaction {
tx.Config.SkipDefaultTransaction = true
}

if config.AllowGlobalUpdate {
txConfig.AllowGlobalUpdate = true
}

if config.FullSaveAssociations {
txConfig.FullSaveAssociations = true
}

  // 如果条件true 会对原db的statement进行深拷贝(并发安全)
  // 如果不进行clone,原db和新db使用的是同一个statement
  // 在分别执行sql后，信息都会存于同一个statement中，相互影响
if config.Context != nil || config.PrepareStmt || config.SkipHooks {
tx.Statement = tx.Statement.clone()
tx.Statement.DB = tx
}

if config.Context != nil {
tx.Statement.Context = config.Context
}

...

if config.DisableNestedTransaction {
txConfig.DisableNestedTransaction = true
}

  // newDB=true clone=1
  // newDB=false clone=2
  // clone值的影响在getInstance()中体现
if !config.NewDB {
tx.clone = 2
}

if config.DryRun {
tx.Config.DryRun = true
}

if config.QueryFields {
tx.Config.QueryFields = true
}

if config.Logger != nil {
tx.Config.Logger = config.Logger
}

if config.NowFunc != nil {
tx.Config.NowFunc = config.NowFunc
}

if config.Initialized {
tx = tx.getInstance()
}

return tx
}

// 在执行大部分语句之前都会调用该方法
// Model() Where() Order() Find() ...
func (db *DB) getInstance() *DB {
  // 根据clone的值，做相应的处理

  // 如果clone=1，会将statement清空，原先设置的条件(比如where order...)都会清除
  // 如果clone=2, 会将statement进行深拷贝，原先的条件保留，但是新老db互不影响()
  // 如果clone=0，直接返回，不做任何操作
  // 做一些build(拼接)操作，比如执行Where(),Order()等操作时，直接使用原db即可，不需要对statement进行拷贝或清除

if db.clone > 0 {
tx := &DB{Config: db.Config, Error: db.Error}

if db.clone == 1 {
// clone with new statement
tx.Statement = &Statement{
DB:       tx,
ConnPool: db.Statement.ConnPool,
Context:  db.Statement.Context,
Clauses:  map[string]clause.Clause{},
Vars:     make([]interface{}, 0, 8),
}
} else {
// with clone statement
tx.Statement = db.Statement.clone()
tx.Statement.DB = tx
}

return tx
}

return db
}

// Transaction start a transaction as a block, return error will rollback, otherwise to commit.
func (db *DB) Transaction(fc func(tx *DB) error, opts ...*sql.TxOptions) (err error) {
panicked := true

if committer, ok := db.Statement.ConnPool.(TxCommitter); ok && committer != nil {
// nested transaction
    // 嵌套事务会进入该分支，原理是一个事务可以分为多个段，用户可以将事务回滚到指定的段，而不是整个事务
    // https://dotnettutorials.net/lesson/savepoint-in-mysql/
if !db.DisableNestedTransaction {
err = db.SavePoint(fmt.Sprintf("sp%p", fc)).Error
if err != nil {
return
}

defer func() {
// Make sure to rollback when panic, Block error or Commit error
if panicked || err != nil {
db.RollbackTo(fmt.Sprintf("sp%p", fc))
}
}()
}
err = fc(db.Session(&Session{NewDB: db.clone == 1}))
} else {
    // 非嵌套事务 开启事务
tx := db.Begin(opts...)
if tx.Error != nil {
return tx.Error
}

defer func() {
// Make sure to rollback when panic, Block error or Commit error
if panicked || err != nil {
        // rollback 事务
tx.Rollback()
}
}()

if err = fc(tx); err == nil {
panicked = false
      // commit 事务
return tx.Commit().Error
}
}

panicked = false
return
}

db.Transaction(func(tx *gorm.DB) error {
  tx.Transaction(func(tx2 *gorm.DB) error {
    return nil
  })
  return nil
})

// A header for a Go map.
type hmap struct {
    // 元素个数，调用 len(map) 时，直接返回此值
    count     int
    flags     uint8
    // buckets 的对数
    B         uint8
    // overflow 的 bucket 近似数
    noverflow uint16
    // 计算 key 的哈希的时候会传入哈希函数
    hash0     uint32
    // 指向 buckets 数组，大小为 2^B
    // 如果元素个数为0，就为 nil
    buckets    unsafe.Pointer
    // 扩容的时候，buckets 长度会是 oldbuckets 的两倍
    oldbuckets unsafe.Pointer
    // 指示扩容进度，小于此地址的 buckets 迁移完成
    nevacuate  uintptr
    extra *mapextra // optional fields
}

type bmap struct {
tophash [bucketCnt]uint8
}

type bmap struct {
    topbits  [8]uint8
    keys     [8]keytype
    values   [8]valuetype
    pad      uintptr
    overflow uintptr
}

func makemap(t *maptype, hint int64, h *hmap, bucket unsafe.Pointer) *hmap {
    // 省略各种条件检查...

    // 找到一个 B，使得 map 的装载因子在正常范围内
    B := uint8(0)
    for ; overLoadFactor(hint, B); B++ {
    }

    // 初始化 hash table
    // 如果 B 等于 0，那么 buckets 就会在赋值的时候再分配
    // 如果长度比较大，分配内存会花费长一点
    buckets := bucket
    var extra *mapextra
    if B != 0 {
        var nextOverflow *bmap
        buckets, nextOverflow = makeBucketArray(t, B)
        if nextOverflow != nil {
            extra = new(mapextra)
            extra.nextOverflow = nextOverflow
        }
    }

    // 初始化 hamp
    if h == nil {
        h = (*hmap)(newobject(t.hmap))
    }
    h.count = 0
    h.B = B
    h.extra = extra
    h.flags = 0
    h.hash0 = fastrand()
    h.buckets = buckets
    h.oldbuckets = nil
    h.nevacuate = 0
    h.noverflow = 0

    return h
}

10010111 | 000011110110110010001111001010100010010110010101010 │ 01010

func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
    // ……

    // 如果 h 什么都没有，返回零值
    if h == nil || h.count == 0 {
        return unsafe.Pointer(&zeroVal[0])
    }

    // 写和读冲突
    if h.flags&hashWriting != 0 {
        throw("concurrent map read and map write")
    }

    // 不同类型 key 使用的 hash 算法在编译期确定
    alg := t.key.alg

    // 计算哈希值，并且加入 hash0 引入随机性
    hash := alg.hash(key, uintptr(h.hash0))

    // 比如 B=5，那 m 就是31，二进制是全 1
    // 求 bucket num 时，将 hash 与 m 相与，
    // 达到 bucket num 由 hash 的低 8 位决定的效果
    m := uintptr(1)<<h.B - 1

    // b 就是 bucket 的地址
    b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))

    // oldbuckets 不为 nil，说明发生了扩容
    if c := h.oldbuckets; c != nil {
        // 如果不是同 size 扩容（看后面扩容的内容）
        // 对应条件 1 的解决方案
        if !h.sameSizeGrow() {
            // 新 bucket 数量是老的 2 倍
            m >>= 1
        }

        // 求出 key 在老的 map 中的 bucket 位置
        oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))

        // 如果 oldb 没有搬迁到新的 bucket
        // 那就在老的 bucket 中寻找
        if !evacuated(oldb) {
            b = oldb
        }
    }

    // 计算出高 8 位的 hash
    // 相当于右移 56 位，只取高8位
    top := uint8(hash >> (sys.PtrSize*8 - 8))

    // 增加一个 minTopHash
    if top < minTopHash {
        top += minTopHash
    }
    for {
        // 遍历 8 个 bucket
        for i := uintptr(0); i < bucketCnt; i++ {
            // tophash 不匹配，继续
            if b.tophash[i] != top {
                continue
            }
            // tophash 匹配，定位到 key 的位置
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
            // key 是指针
            if t.indirectkey {
                // 解引用
                k = *((*unsafe.Pointer)(k))
            }
            // 如果 key 相等
            if alg.equal(key, k) {
                // 定位到 value 的位置
                v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
                // value 解引用
                if t.indirectvalue {
                    v = *((*unsafe.Pointer)(v))
                }
                return v
            }
        }

        // bucket 找完（还没找到），继续到 overflow bucket 里找
        b = b.overflow(t)
        // overflow bucket 也找完了，说明没有目标 key
        // 返回零值
        if b == nil {
            return unsafe.Pointer(&zeroVal[0])
        }
    }
}

dataOffset = unsafe.Offsetof(struct {
        b bmap
        v int64
    }{}.v)

b = b.overflow(t)

// 空的 cell，也是初始时 bucket 的状态
empty          = 0
// 空的 cell，表示 cell 已经被迁移到新的 bucket
evacuatedEmpty = 1
// key,value 已经搬迁完毕，但是 key 都在新 bucket 前半部分，
// 后面扩容部分会再讲到。
evacuatedX     = 2
// 同上，key 在后半部分
evacuatedY     = 3
// tophash 的最小正常值
minTopHash     = 4

func evacuated(b *bmap) bool {
    h := b.tophash[0]
    return h > empty && h < minTopHash
}

func mapdelete(t *maptype, h *hmap, key unsafe.Pointer)

// 对 key 清零
if t.indirectkey {
    *(*unsafe.Pointer)(k) = nil
} else {
    typedmemclr(t.key, k)
}

// 对 value 清零
if t.indirectvalue {
    *(*unsafe.Pointer)(v) = nil
} else {
    typedmemclr(t.elem, v)
}

// 生成随机数 r
r := uintptr(fastrand())
if h.B > 31-bucketCntBits {
    r += uintptr(fastrand()) << 31
}

// 从哪个 bucket 开始遍历
it.startBucket = r & (uintptr(1)<<h.B - 1)
// 从 bucket 的哪个 cell 开始遍历
it.offset = uint8(r >> h.B & (bucketCnt - 1))

loadFactor := count / (2^B)

// src/runtime/hashmap.go/mapassign

// 触发扩容时机
if !h.growing() && (overLoadFactor(int64(h.count), h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
        hashGrow(t, h)
    }

// 装载因子超过 6.5
func overLoadFactor(count int64, B uint8) bool {
    return count >= bucketCnt && float32(count) >= loadFactor*float32((uint64(1)<<B))
}

// overflow buckets 太多
func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
    if B < 16 {
        return noverflow >= uint16(1)<<B
    }
    return noverflow >= 1<<15
}

func hashGrow(t *maptype, h *hmap) {
    // B+1 相当于是原来 2 倍的空间
    bigger := uint8(1)

    // 对应条件 2
    if !overLoadFactor(int64(h.count), h.B) {
        // 进行等量的内存扩容，所以 B 不变
        bigger = 0
        h.flags |= sameSizeGrow
    }
    // 将老 buckets 挂到 buckets 上
    oldbuckets := h.buckets
    // 申请新的 buckets 空间
    newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger)

    flags := h.flags &^ (iterator | oldIterator)
    if h.flags&iterator != 0 {
        flags |= oldIterator
    }
    // 提交 grow 的动作
    h.B += bigger
    h.flags = flags
    h.oldbuckets = oldbuckets
    h.buckets = newbuckets
    // 搬迁进度为 0
    h.nevacuate = 0
    // overflow buckets 数为 0
    h.noverflow = 0

    // ……
}

x = 01010011
y = 01010100
z = x &^ y = 00000011

// 可能有迭代器使用 buckets
iterator     = 1
// 可能有迭代器使用 oldbuckets
oldIterator  = 2
// 有协程正在向 map 中写入 key
hashWriting  = 4
// 等量扩容（对应条件 2）
sameSizeGrow = 8

func growWork(t *maptype, h *hmap, bucket uintptr) {
    // 确认搬迁老的 bucket 对应正在使用的 bucket
    evacuate(t, h, bucket&h.oldbucketmask())

    // 再搬迁一个 bucket，以加快搬迁进程
    if h.growing() {
        evacuate(t, h, h.nevacuate)
    }
}

func (h *hmap) growing() bool {
    return h.oldbuckets != nil
}

func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
    // 定位老的 bucket 地址
    b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
    // 结果是 2^B，如 B = 5，结果为32
    newbit := h.noldbuckets()
    // key 的哈希函数
    alg := t.key.alg
    // 如果 b 没有被搬迁过
    if !evacuated(b) {
        var (
            // 表示bucket 移动的目标地址
            x, y   *bmap
            // 指向 x,y 中的 key/val
            xi, yi int
            // 指向 x，y 中的 key
            xk, yk unsafe.Pointer
            // 指向 x，y 中的 value
            xv, yv unsafe.Pointer
        )
        // 默认是等 size 扩容，前后 bucket 序号不变
        // 使用 x 来进行搬迁
        x = (*bmap)(add(h.buckets, oldbucket*uintptr(t.bucketsize)))
        xi = 0
        xk = add(unsafe.Pointer(x), dataOffset)
        xv = add(xk, bucketCnt*uintptr(t.keysize))、

        // 如果不是等 size 扩容，前后 bucket 序号有变
        // 使用 y 来进行搬迁
        if !h.sameSizeGrow() {
            // y 代表的 bucket 序号增加了 2^B
            y = (*bmap)(add(h.buckets, (oldbucket+newbit)*uintptr(t.bucketsize)))
            yi = 0
            yk = add(unsafe.Pointer(y), dataOffset)
            yv = add(yk, bucketCnt*uintptr(t.keysize))
        }

        // 遍历所有的 bucket，包括 overflow buckets
        // b 是老的 bucket 地址
        for ; b != nil; b = b.overflow(t) {
            k := add(unsafe.Pointer(b), dataOffset)
            v := add(k, bucketCnt*uintptr(t.keysize))

            // 遍历 bucket 中的所有 cell
            for i := 0; i < bucketCnt; i, k, v = i+1, add(k, uintptr(t.keysize)), add(v, uintptr(t.valuesize)) {
                // 当前 cell 的 top hash 值
                top := b.tophash[i]
                // 如果 cell 为空，即没有 key
                if top == empty {
                    // 那就标志它被"搬迁"过
                    b.tophash[i] = evacuatedEmpty
                    // 继续下个 cell
                    continue
                }
                // 正常不会出现这种情况
                // 未被搬迁的 cell 只可能是 empty 或是
                // 正常的 top hash（大于 minTopHash）
                if top < minTopHash {
                    throw("bad map state")
                }

                k2 := k
                // 如果 key 是指针，则解引用
                if t.indirectkey {
                    k2 = *((*unsafe.Pointer)(k2))
                }

                // 默认使用 X，等量扩容
                useX := true
                // 如果不是等量扩容
                if !h.sameSizeGrow() {
                    // 计算 hash 值，和 key 第一次写入时一样
                    hash := alg.hash(k2, uintptr(h.hash0))

                    // 如果有协程正在遍历 map
                    if h.flags&iterator != 0 {
                        // 如果出现 相同的 key 值，算出来的 hash 值不同
                        if !t.reflexivekey && !alg.equal(k2, k2) {
                            // 只有在 float 变量的 NaN() 情况下会出现
                            if top&1 != 0 {
                                // 第 B 位置 1
                                hash |= newbit
                            } else {
                                // 第 B 位置 0
                                hash &^= newbit
                            }
                            // 取高 8 位作为 top hash 值
                            top = uint8(hash >> (sys.PtrSize*8 - 8))
                            if top < minTopHash {
                                top += minTopHash
                            }
                        }
                    }

                    // 取决于新哈希值的 oldB+1 位是 0 还是 1
                    // 详细看后面的文章
                    useX = hash&newbit == 0
                }

                // 如果 key 搬到 X 部分
                if useX {
                    // 标志老的 cell 的 top hash 值，表示搬移到 X 部分
                    b.tophash[i] = evacuatedX
                    // 如果 xi 等于 8，说明要溢出了
                    if xi == bucketCnt {
                        // 新建一个 bucket
                        newx := h.newoverflow(t, x)
                        x = newx
                        // xi 从 0 开始计数
                        xi = 0
                        // xk 表示 key 要移动到的位置
                        xk = add(unsafe.Pointer(x), dataOffset)
                        // xv 表示 value 要移动到的位置
                        xv = add(xk, bucketCnt*uintptr(t.keysize))
                    }
                    // 设置 top hash 值
                    x.tophash[xi] = top
                    // key 是指针
                    if t.indirectkey {
                        // 将原 key（是指针）复制到新位置
                        *(*unsafe.Pointer)(xk) = k2 // copy pointer
                    } else {
                        // 将原 key（是值）复制到新位置
                        typedmemmove(t.key, xk, k) // copy value
                    }
                    // value 是指针，操作同 key
                    if t.indirectvalue {
                        *(*unsafe.Pointer)(xv) = *(*unsafe.Pointer)(v)
                    } else {
                        typedmemmove(t.elem, xv, v)
                    }

                    // 定位到下一个 cell
                    xi++
                    xk = add(xk, uintptr(t.keysize))
                    xv = add(xv, uintptr(t.valuesize))
                } else { // key 搬到 Y 部分，操作同 X 部分
                    // ……
                    // 省略了这部分，操作和 X 部分相同
                }
            }
        }
        // 如果没有协程在使用老的 buckets，就把老 buckets 清除掉，帮助gc
        if h.flags&oldIterator == 0 {
            b = (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
            // 只清除bucket 的 key,value 部分，保留 top hash 部分，指示搬迁状态
            if t.bucket.kind&kindNoPointers == 0 {
                memclrHasPointers(add(unsafe.Pointer(b), dataOffset), uintptr(t.bucketsize)-dataOffset)
            } else {
                memclrNoHeapPointers(add(unsafe.Pointer(b), dataOffset), uintptr(t.bucketsize)-dataOffset)
            }
        }
    }

    // 更新搬迁进度
    // 如果此次搬迁的 bucket 等于当前进度
    if oldbucket == h.nevacuate {
        // 进度加 1
        h.nevacuate = oldbucket + 1
        // Experiments suggest that 1024 is overkill by at least an order of magnitude.
        // Put it in there as a safeguard anyway, to ensure O(1) behavior.
        // 尝试往后看 1024 个 bucket
        stop := h.nevacuate + 1024
        if stop > newbit {
            stop = newbit
        }
        // 寻找没有搬迁的 bucket
        for h.nevacuate != stop && bucketEvacuated(t, h, h.nevacuate) {
            h.nevacuate++
        }

        // 现在 h.nevacuate 之前的 bucket 都被搬迁完毕

        // 所有的 buckets 搬迁完毕
        if h.nevacuate == newbit {
            // 清除老的 buckets
            h.oldbuckets = nil
            // 清除老的 overflow bucket
            // 回忆一下：[0] 表示当前 overflow bucket
            // [1] 表示 old overflow bucket
            if h.extra != nil {
                h.extra.overflow[1] = nil
            }
            // 清除正在扩容的标志位
            h.flags &^= sameSizeGrow
        }
    }
}

type SliceHeader struct {
Data uintptr
Len  int
Cap  int
}

arr[0:3] or slice[0:3]
slice := []int{1, 2, 3}
slice := make([]int, 10)

// 底层数据长度为0
nums := make([]int,0)
nums := []int{}

// 未分配底层数组
var nums []int

var vstat [3]int // 1.根据切片中的元素数量对底层数组的大小进行推断并创建一个数组；
vstat[0] = 1 // 2.将这些字面量元素存储到初始化的数组中；
vstat[1] = 2
vstat[2] = 3
var vauto *[3]int = new([3]int) // 3.创建一个同样指向 [3]int 类型的数组指针；
*vauto = vstat // 4.将静态存储区的数组 vstat 赋值给 vauto 指针所在的地址；
slice := vauto[:] //5.通过 [:] 操作获取一个底层使用 vauto 的切片；

1. 检查len是否传入，检查len是否小于cap
2. 当切片发生逃逸或者非常大时，运行时需要 runtime.makeslice 在堆上初始化切片
3. 当前的切片不会发生逃逸并且切片非常小时，会使用与字面量相同的方式创建

func makeslice(et *_type, len, cap int) unsafe.Pointer {
mem, overflow := math.MulUintptr(et.size, uintptr(cap))
if overflow || mem > maxAlloc || len < 0 || len > cap {
mem, overflow := math.MulUintptr(et.size, uintptr(len))
if overflow || mem > maxAlloc || len < 0 {
panicmakeslicelen()
}
panicmakeslicecap()
}

return mallocgc(mem, et, true)
}

a := make([]int,0,1)
// 当容量足够时，直接添加
a = append(a,1)
// 当容量不足时，先扩容(拷贝原先的数据),再添加 这是底层数组已经改变
a = append(a,2)

func growslice(et *_type, old slice, cap int) slice {
    ...
    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.len < 1024 {
            newcap = doublecap
        } else {
            for 0 < newcap && newcap < cap {
                newcap += newcap / 4
            }
            ...
        }
    }
    ...
}

var overflow bool
var lenmem, newlenmem, capmem uintptr
switch {
case et.size == 1:
lenmem = uintptr(old.len)
newlenmem = uintptr(cap)
capmem = roundupsize(uintptr(newcap))
overflow = uintptr(newcap) > maxAlloc
newcap = int(capmem)
case et.size == sys.PtrSize:
lenmem = uintptr(old.len) * sys.PtrSize
newlenmem = uintptr(cap) * sys.PtrSize
capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
newcap = int(capmem / sys.PtrSize)
case isPowerOfTwo(et.size):
...
default:
...
}

// roundupsize函数会将待申请的内存向上取整 取整时会使用 runtime.class_to_size 数组
var class_to_size = [_NumSizeClasses]uint16{0,8,16,32,48,64,80,...}

a = []int{}
a = a.append(1,2,3,4,5) // len=5 cap=6
// 期望容量(5)大于原容量的两倍(2*0) 得到新容量(5) 占用内存(5*8byte) 
// 进行内存对齐得到（48）最终容量(48/8==6)

a = []int{1,2,3,4}
a = a.append(5) // len=5 cap=8
// 期望容量(5)小于1024 (2*0) 新容量为原容量的两倍(8) 占用内存(8*8byte) 
// 进行内存对齐得到（64）最终容量(64/8==8)

// 将src的内容拷贝到dst中  拷贝的大小取两者中的较小值
copy(dst, src)

package main

import "fmt"

func myAppend(s []int) []int {
// 这里 s 虽然改变了，但并不会影响外层函数的 s
s = append(s, 100)
return s
}

func myAppendPtr(s *[]int) {
// 会改变外层 s 本身
*s = append(*s, 100)
return
}

func main() {
s := []int{1, 1, 1}
newS := myAppend(s) 

fmt.Println(s) // 1,1,1
fmt.Println(newS) // 1,1,1,100

s = newS

myAppendPtr(&s)
fmt.Println(s) // 1,1,1,100,1000
}

type Socket struct {
  FileDescriptor int
}

func (socket Socket) Read(bytes []byte) (int, error) {
  if len(bytes) == 0 {
    return 0, nil
  }
  numBytesRead, err :=
    syscall.Read(socket.FileDescriptor, bytes)
  if err != nil {
    numBytesRead = 0
  }
  return numBytesRead, err
}

func (socket Socket) Write(bytes []byte) (int, error) {
  numBytesWritten, err :=
    syscall.Write(socket.FileDescriptor, bytes)
  if err != nil {
    numBytesWritten = 0
  }
  return numBytesWritten, err
}

func (socket *Socket) Close() error {
  return syscall.Close(socket.FileDescriptor)
}

func (socket *Socket) String() string {
  return strconv.Itoa(socket.FileDescriptor)
}

func Listen(ip string, port int) (*Socket, error) {
  // 1. 创建套接字
  socket := &Socket{}
// AF_INET 表示IPV4
  // SOCK_STREAM 表示有序的、可靠的、基于双向连接的字节流
  // 0在SOCK_STREAM套接字中表示TCP
  socketFileDescriptor, err :=
    syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
  if err != nil {
    return nil, fmt.Errorf("failed to create socket (%v)", err)
  }
  socket.FileDescriptor = socketFileDescriptor

  // 2. 绑定ip和端口
  socketAddress := &syscall.SockaddrInet4{Port: port}
  copy(socketAddress.Addr[:], net.ParseIP(ip))
  if err = syscall.Bind(socket.FileDescriptor, socketAddress);
    err != nil {
    return nil, fmt.Errorf("failed to bind socket (%v)", err)
  }

  // 3. 开始监听,接收连接请求 SOMAXCONN设置最大等待的连接数
  if err = syscall.Listen(socket.FileDescriptor, syscall.SOMAXCONN);
    err != nil {
    return nil, fmt.Errorf("failed to listen on socket (%v)", err)
  }

  return socket, nil
}

type EventLoop struct {
  KqueueFileDescriptor int
  SocketFileDescriptor int
}