func add1(x, y int) (z int) {
    { // 不能在一个级别，引发 "z redeclared in this block" 错误。
        var z = x + y
        // return   // Error: z is shadowed during return
        return z // 必须显式返回。
    }
}

func add2(x, y int) (z int) {
    defer func() {
        z++
        println(z) // 输出: 203
    }()

    z = x + y
    return z + 200 // 执行顺序: (z = z + 200) -> (call defer) -> (return)
}

func add3(x,y int) int {
    z := x+y
    defer func() {
        z++
        println(z) // 输出: 204
    }
    return z + 200 // 执行顺序：(s = z + 200) -> (call defer) -> (return )
}


func main() {
    println(add1(1, 2)) // 输出：3
    println(add2(1, 2)) // 输出: 204
    println(add3(1, 2)) // 输出: 203
}

f, err := os.Open("test.txt")
if err != nil {
    log.Fatal(err)
}

var str strings.Builder
for i := 0; i < 1000; i++ {
    str.WriteString("a")
}
fmt.Println(str.String())

package main

import (
    "fmt"
)
func main() {
    a := `Go语言`
    // 这里string底层为byte，`语言`为utf-8编码因此使用6个字节
    fmt.Println(len(a)) // 8
    // 这里转换为rune数组，每个字符都是一个rune，长度为4，内存为16字节
    fmt.Println(len([]rune(a))) // 4
    // 输出内存中第3个字节内容，长度为1字节
    fmt.Println(a[2]) // 232
    // 输出第二个rune内容，长度为4字节
    fmt.Println([]rune(a)[2]) // 35821
    fmt.Println("Hello W3Cschool!")
}

func test() int {
	i := 0

    {
        defer func() {
            fmt.Println("defer0")    
        }()
    }

	defer func() {
		fmt.Println("defer1")
	}()
	defer func() {
		i += 1
		fmt.Println("defer2")
	}()
	return i
}


func test1() (i  int) {
    i = 0
	defer func() {
		i += 1
		fmt.Println("defer4")
	}()
	return i
}

func main() {
	fmt.Println("return", test())
    fmt.Println("return", test1())
}
// defer0
// defer2
// defer1
// return 0
// defer4
// return 1

a, b := "A", "B"
a, b = b, a
fmt.Println(a, b) // B A

package main

import (
	"fmt"
	"reflect"
)

type User struct {
	Name string `json:"name" mytag:"myName"`
	Age  int    `json:"age" mytag:"myAge"`
}

func main() {
	user := User{"Bob", 30}
	// 获取值反射
	v := reflect.ValueOf(user)
	// 获取类型
	t := v.Type()
	for i := 0; i < t.NumField(); i++ {
		// 字段
		field := t.Field(i)
		// 输出字段和值
		fmt.Println(field.Name, field.Tag.Get("json"), field.Tag.Get("mytag"), v.FieldByName(field.Name))
	}
}

// 输出：
// Name name myName Bob
// Age age myAge 30

func StringSliceEqualBCE(a, b []string) bool {
    if len(a) != len(b) {
        return false
    }

    if (a == nil) != (b == nil) {
        return false
    }

    b = b[:len(a)]
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

type Stu struct {
	Name string
}

func main() {
	fmt.Printf("%v\n", Stu{"Tom"}) // {Tom}
	fmt.Printf("%+v\n", Stu{"Tom"}) // {Name:Tom}
}

type StuType int32

const (
	Type1 StuType = iota
	Type2
	Type3
	Type4
)

func main() {
	fmt.Println(Type1, Type2, Type3, Type4) // 0, 1, 2, 3
}

package main 

// 1. 输出值
func PrintTest() {
    fmt.Println(unsafe.Sizeof(struct{}{})) // 0
}

// 2. 构造set
type Set map[string]struct{}

func SetTest() {
    set := make(Set)

	for _, item := range []string{"A", "A", "B", "C"} {
		set[item] = struct{}{}
	}
	fmt.Println(len(set)) // 3
	if _, ok := set["A"]; ok {
		fmt.Println("A exists") // A exists
	}
}

// 3. 使用管道
func ChannelTest() {
    ch := make(chan struct{}, 1)
	go func() {
		<-ch
		// do something
	}()
	ch <- struct{}{}
}

// 4. 声明方法继承
type Lamp struct{}

func (l Lamp) On() {
        println("On")

}
func (l Lamp) Off() {
        println("Off")
}

func main() {
    PrintTest()
    SetTest()
    ChannelTest()
}

// a 包
// a.go
package a

import _ "main/b"

func init() {
	println("init a")
}

// b 包
// b.go
package b

import _ "main/c"

func init() {
	println("init b")
}

// c 包
// c.go
package c

func init() {
	println("init c")
}

// main 包
// main.go
package main

import (
	_ "main/a"
)

func init() {
	println("init main")
}

func main() {
	println("main")
}

// 1. 返回指针逃逸
// d 在堆上分配内存
func createDemo(name string) *Demo {
	d := new(Demo) // 局部变量 d 逃逸到堆
	d.name = name
	return d
}

// 2. interface 逃逸
// 局部变量demo 不会发生逃逸，但是demo.name 会逃逸
func test(demo *Demo) {
	fmt.Println(demo.name)
}

// 3. 内存不足逃逸
// 3.1 超过64KB发生逃逸
func generate8192() {
	nums := make([]int, 8192) // = 64KB
	for i := 0; i < 8192; i++ {
		nums[i] = rand.Int()
	}
}
// 3.2 不确定大小逃逸
func generate(n int) {
	nums := make([]int, n) // 不确定大小
	for i := 0; i < n; i++ {
		nums[i] = rand.Int()
	}
}

// 4. 闭包逃逸
// Increase() 返回值是一个闭包函数
// 函数访问了外部变量n,n会一直存在直到in 被销毁
func IncreaseTest() {
    in := Increase()
	fmt.Println(in()) // 1
}

func Increase() func() int {
	n := 0
	return func() int {
		n++
		return n
	}
}

// runtime/runtime2.go
// 空数据类型指针--不带方法
type eface struct {
	_type *_type  // 类型指针
	data  unsafe.Pointer // 数据值指针
}

// runtime/runtime2.go
// 非空接口--带方法
type iface struct {
    tab  *itab          // 对应的虚拟函数表
    data unsafe.Pointer //指向原始数据指针
}

package main

type TestStruct struct{}

// Go 语言的接口类型不是任意类型
// 这里进行了类型转换，将类型转换为了*TestStruct类型
// 包含了*TestStruct的类型信息
func NilOrNot(v interface{}) bool {
	return v == nil
}

func main() {
	var s *TestStruct
	fmt.Println(s == nil)      // #=> true
	fmt.Println(NilOrNot(s))   // #=> false
}

$ go run main.go
true
false

type MyInterface interface {
    DoSomething()
}

type MyType struct{}

func (mt *MyType) DoSomething() {}

func test2() {
    var i MyInterface
    var t *MyType

    fmt.Println(i == nil)  // 输出：true
    fmt.Println(t == nil)  // 输出：true
 	fmt.Println(i == t)  // 输出：false
	
    i = t
    fmt.Println(i == nil)  // 输出：false
}



func test1() {
    var p *int = nil 
    // 此时i 中的T = *int, V= nil
    var i interface{} = p
    // 类型相同与值相同--相等
    fmt.Println(i == p) // true
    // p 值为nil--相等
	fmt.Println(p == nil) // true
	// 将nil 转换为接口(T=nil, V=nil), i T值不相同--不相等
    fmt.Println(i == nil) // false -- i 存在类型值
}

type T string

func (t *T) hello() {
	fmt.Println("hello")
}

func main() {
	var t1 T = "ABC"
	t1.hello() // hello
    // t2 为常量--非*T 类型
	const t2 T = "ABC"
	t2.hello() // error: cannot call pointer method on t
}

ch1 := make(chan struct{})
ch2 := make(chan struct{})
var wg sync.WaitGroup
wg.Add(2)

go func() {
   defer wg.Done()
   for i := 1; i <= 10; i += 2 {
      <-ch1
      fmt.Println(i)
      ch2 <- struct{}{}
   }
   <-ch1
}()

go func() {
   defer wg.Done()
   for i := 2; i <= 10; i += 2 {
      <-ch2
      fmt.Println(i)
      ch1 <- struct{}{}
}

ch1 <- struct{}{}
// 等待协程执行完毕
wg.Wait()

// 缺少接收器导致死锁
func query() int {
	ch := make(chan int)
	for i := 0; i < 1000; i++ {
		go func() { ch <- 0 }()
	}
	return <-ch
}

func queryTest() {
	for i := 0; i < 4; i++ {
		query()
		fmt.Printf("goroutines: %d\n", runtime.NumGoroutine())
	}
}
// goroutines: 1001
// goroutines: 2000
// goroutines: 2999
// goroutines: 3998


// 这里死循环请求
func request(url string, wg *sync.WaitGroup) {
    i := 0
    for {
        if _, err := http.Get(url); err == nil {
            // write to db
            break
        }
        i++
        if i >= 3 {
            break
        }
        time.Sleep(time.Second)
    }
    wg.Done()
}

func waitTest() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go request(fmt.Sprintf("https://127.0.0.1:8080/%d", i), &wg)
    }
    wg.Wait()
}

runtime.GOMAXPROCS(1) // 限制同时执行Go代码的操作系统线程数为 1

func main() {
	const (
		a, b = "golang", 100
		d, e
		f bool = true
		g
	)
	fmt.Println(d, e, g)
}
// golang 100 true

func main() {
    const (
        a, b = "golang", 100
        d, e = "golang", 100
        f bool = true
        g bool = true
    )
    fmt.Println(d, e, g)
}

func main() {
    const N = 100
    var x int = N

    const M int32 = 100
    var y int = M
    fmt.Println(x, y)
}

// 编译失败：cannot use M (type int32) as type int in assignment

func main() {
    var a int8 = -1
    var b int8 = -128 / a
    fmt.Println(b)
}
// -128

func main() {
    const a int8 = -1
    var b int8 = -128 / a
    fmt.Println(b)
}

func main() {
    var err error
    if err == nil {
        err := fmt.Errorf("err")
        fmt.Println(1, err)
    }
    if err != nil {
        fmt.Println(2, err)
    }
}
// 1 err

type T struct{}

func (t T) f(n int) T {
    fmt.Print(n)
    return t
}

func main() {
    var t T
    defer t.f(1).f(2)
    fmt.Print(3)
}
// 132

package main

import "fmt"

func f(n int) {
    // defer 执行语句与函数，在开始时就确定
    // 这里n进行了值拷贝，输出为1
    defer fmt.Println(n)
    n += 100
}

func f3(n *int) {
    // 这里*n一开始输入就确定了
    // 输出为3
    defer fmt.Println(*n)
    n += 100
}

func f2(n int) {
    // 设置输出为最终的n
    // 因此n输出为102
    defer func() {
        fmt.Println(n)
    }()
    // 这里直接输出n
    // n 在设置时就确定了，因此为2
    defer func(n int ) {
        fmt.Println(n)
    }(n)
    // 设置参数为n指针，最终输出为n的引用值
    // 102
    defer func(n *int ) {
        fmt.Println(*n)
    }(&n)
    n += 100

}

func main() {
    f(1)
    f2(2)
    a := 3
    f3(&a)
}

// 1  
// 102
// 2
// 102
// 3

func main() {
    n := 1
    if n == 1 {
        defer fmt.Println(n)
        n += 100
    }
    fmt.Println(n)
}
// 101
// 1

package main

import "fmt"

type girl struct {
	Name string
	Age int
}

func main() {
	gl := make(map[string]*girl)
	studs := []girl{
		{Name: "Lili", Age: 23},
		{Name: "Lucy", Age: 24},
		{Name: "Han Mei", Age: 21},
	}

	for _, v := range studs {
        fmt.Printf("%s addr: %v\n", v.Name, &v.Age)
		gl[v.Name] = &v
	}

	for mk, mv := range gl {
		fmt.Println(mk, "=>", mv.Age)
	}
}
// main.go
// Lili addr: 0xc0000a4028
// Lili => 21
// Lucy addr: 0xc0000a4028
// Lucy => 21
// Han Mei addr: 0xc0000a4028
// Han Mei => 21

func main() {
    type User struct {
        Name string `testTag:"name"`
        Age int `testTag:"age"`
    }
    v := refect.Valueof(user)
    t := v.Type()
    for i:=0; i < t.NumField(); i++ {
        field := t.Fieid(i)
        tagName :=  field.Tag.Get("testTag")
        fieldVal := v.FieldByName(field.Name)
        fmt.Printf("tagName %v val %v", tagName, fieldVal)
    }
}

// /go/src/runtime/malloc.go
// base address for all 0-byte allocations
var zerobase uintptr

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
   
    ······

    if size == 0 {
   
       return unsafe.Pointer(&zerobase)
    }
    ······

// context/context.go
type Context interface {
	// Deadline returns the time when work done on behalf of this context
	// should be canceled. Deadline returns ok==false when no deadline is
	// set. Successive calls to Deadline return the same results.
	Deadline() (deadline time.Time, ok bool)

	// Done returns a channel that's closed when work done on behalf of this
	// context should be canceled. Done may return nil if this context can
	// never be canceled. Successive calls to Done return the same value.
	// The close of the Done channel may happen asynchronously,
	// after the cancel function returns.
	//
	// WithCancel arranges for Done to be closed when cancel is called;
	// WithDeadline arranges for Done to be closed when the deadline
	// expires; WithTimeout arranges for Done to be closed when the timeout
	// elapses.
	//
	// Done is provided for use in select statements:
	//
	//  // Stream generates values with DoSomething and sends them to out
	//  // until DoSomething returns an error or ctx.Done is closed.
	//  func Stream(ctx context.Context, out chan<- Value) error {
	//  	for {
	//  		v, err := DoSomething(ctx)
	//  		if err != nil {
	//  			return err
	//  		}
	//  		select {
	//  		case <-ctx.Done():
	//  			return ctx.Err()
	//  		case out <- v:
	//  		}
	//  	}
	//  }
	//
	// See https://blog.golang.org/pipelines for more examples of how to use
	// a Done channel for cancellation.
	Done() <-chan struct{}

	// If Done is not yet closed, Err returns nil.
	// If Done is closed, Err returns a non-nil error explaining why:
	// Canceled if the context was canceled
	// or DeadlineExceeded if the context's deadline passed.
	// After Err returns a non-nil error, successive calls to Err return the same error.
	Err() error

	// Value returns the value associated with this context for key, or nil
	// if no value is associated with key. Successive calls to Value with
	// the same key returns the same result.
	//
	// Use context values only for request-scoped data that transits
	// processes and API boundaries, not for passing optional parameters to
	// functions.
	//
	// A key identifies a specific value in a Context. Functions that wish
	// to store values in Context typically allocate a key in a global
	// variable then use that key as the argument to context.WithValue and
	// Context.Value. A key can be any type that supports equality;
	// packages should define keys as an unexported type to avoid
	// collisions.
	//
	// Packages that define a Context key should provide type-safe accessors
	// for the values stored using that key:
	//
	// 	// Package user defines a User type that's stored in Contexts.
	// 	package user
	//
	// 	import "context"
	//
	// 	// User is the type of value stored in the Contexts.
	// 	type User struct {...}
	//
	// 	// key is an unexported type for keys defined in this package.
	// 	// This prevents collisions with keys defined in other packages.
	// 	type key int
	//
	// 	// userKey is the key for user.User values in Contexts. It is
	// 	// unexported; clients use user.NewContext and user.FromContext
	// 	// instead of using this key directly.
	// 	var userKey key
	//
	// 	// NewContext returns a new Context that carries value u.
	// 	func NewContext(ctx context.Context, u *User) context.Context {
	// 		return context.WithValue(ctx, userKey, u)
	// 	}
	//
	// 	// FromContext returns the User value stored in ctx, if any.
	// 	func FromContext(ctx context.Context) (*User, bool) {
	// 		u, ok := ctx.Value(userKey).(*User)
	// 		return u, ok
	// 	}
	Value(key any) any
}

type emptyCtx int
// 执行deadline
func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
	return
}

// 执行相关操作
func (*emptyCtx) Done() <-chan struct{} {
	return nil
}

// 对应错误信息
func (*emptyCtx) Err() error {
	return nil
}

// 查询对应值
func (*emptyCtx) Value(key any) any {
	return nil
}

// 字符串
func (e *emptyCtx) String() string {
	switch e {
	case background:
		return "context.Background"
	case todo:
		return "context.TODO"
	}
	return "unknown empty Context"
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)

// Background returns a non-nil, empty Context. It is never canceled, has no
// values, and has no deadline. It is typically used by the main function,
// initialization, and tests, and as the top-level Context for incoming
// requests.
func Background() Context {
	return background
}

func httpRequest(ctx context.Context) {
	for {
		// 处理http请求
		select {
		case <- ctx.Done():
			fmt.Println("Request timed out")
			return
		case <- time.After(time.Second):
			fmt.Println("Loading...")
		}
	}
}

func main() {
	fmt.Println("start TestTimeoutContext")
	ctx, cancel := context.WithTimeout(context.Background(), time.Second * 3)
	defer cancel()
	httpRequest(ctx)
	time.Sleep(time.Second * 5)
}

//start TestTimeoutContext
//Loading...
//Loading...
//Request timed out

func gen(ctx context.Context) <-chan int {
	ch := make(chan int)
	go func() {
		var n int
		for {
			select {
			case ch <- n:
				n++
				time.Sleep(time.Second)
			case <-ctx.Done():
				return
			}
		}
	}()
	return ch
}

func main() {
	// 创建一个Cancel context
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	for n := range gen(ctx) {
		fmt.Println(n)
		if n == 5 {
			// 达到要求之后触发cancel
			cancel()
			break
		}
	}
}
//0
//1
//2
//3
//4
//5

type hchan struct {
	qcount   uint           // 队列中的总元素个数
	dataqsiz uint           // 环形队列大小，即可存放元素的个数
	buf      unsafe.Pointer // 环形队列指针
	elemsize uint16 //每个元素的大小
	closed   uint32 //标识关闭状态
	elemtype *_type // 元素类型
	sendx    uint   // 发送索引，元素写入时存放到队列中的位置
	recvx    uint   // 接收索引，元素从队列的该位置读出
	recvq    waitq  // 等待读消息的goroutine队列
	sendq    waitq  // 等待写消息的goroutine队列

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	//
	// Do not change another G's status while holding this lock
	// (in particular, do not ready a G), as this can deadlock
	// with stack shrinking.
	lock mutex //互斥锁，chan不允许并发读写
}

type waitq struct {
	first *sudog
	last  *sudog
}

// sudog represents a g in a wait list, such as for sending/receiving
// on a channel.
//
// sudog is necessary because the g ↔ synchronization object relation
// is many-to-many. A g can be on many wait lists, so there may be
// many sudogs for one g; and many gs may be waiting on the same
// synchronization object, so there may be many sudogs for one object.
//
// sudogs are allocated from a special pool. Use acquireSudog and
// releaseSudog to allocate and free them.
type sudog struct {
	// The following fields are protected by the hchan.lock of the
	// channel this sudog is blocking on. shrinkstack depends on
	// this for sudogs involved in channel ops.

	g *g

	next *sudog
	prev *sudog
	elem unsafe.Pointer // data element (may point to stack)

	// The following fields are never accessed concurrently.
	// For channels, waitlink is only accessed by g.
	// For semaphores, all fields (including the ones above)
	// are only accessed when holding a semaRoot lock.

	acquiretime int64
	releasetime int64
	ticket      uint32

	// isSelect indicates g is participating in a select, so
	// g.selectDone must be CAS'd to win the wake-up race.
	isSelect bool

	// success indicates whether communication over channel c
	// succeeded. It is true if the goroutine was awoken because a
	// value was delivered over channel c, and false if awoken
	// because c was closed.
	success bool

	parent   *sudog // semaRoot binary tree
	waitlink *sudog // g.waiting list or semaRoot
	waittail *sudog // semaRoot
	c        *hchan // channel
}

type hmap struct {
  count     int              // 存储的键值对数目,调用len时直接返回此值
  flags     uint8            // 状态标志（是否处于正在写入的状态等）
  B         uint8            // 桶的数目为 2^B
  noverflow uint16           // 使用的溢出桶的数量
  hash0     uint32           // 生成hash的随机数种子

  buckets    unsafe.Pointer  // bucket数组指针，数组的大小为2^B（桶）
  oldbuckets unsafe.Pointer  // 扩容阶段用于记录旧桶用到的那些溢出桶的地址
  nevacuate  uintptr         // 记录渐进式扩容阶段下一个要迁移的旧桶编号
  extra *mapextra            // 指向mapextra结构体里边记录的都是溢出桶相关的信息
}


//  buckets 指向的真实指针地址
type bmap struct {
    topbits  [8]uint8   // 高位字段，用于进行快速的hash查找
    keys     [8]keytype  // key数组
    values   [8]valuetype // val数组
    pad      uintptr // 字节对齐扩充字段
    overflow uintptr // 溢出桶指针地址
}

// map扩容
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	...
again:
	bucket := hash & bucketMask(h.B)
    // 已经处于扩容
	if h.growing() {
        // 执行真正的扩容函数
		growWork(t, h, bucket)
	}
	b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
	top := tophash(hash)

    
    ...
	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
		hashGrow(t, h)
		goto again
	}
	...
}

func growWork(t *maptype, h *hmap, bucket uintptr) {
	// make sure we evacuate the oldbucket corresponding
	// to the bucket we're about to use
	evacuate(t, h, bucket&h.oldbucketmask())

	// evacuate one more oldbucket to make progress on growing
	if h.growing() {
		evacuate(t, h, h.nevacuate)
	}
}

// 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) {
	bigger := uint8(1)
    // 检查是否为装载因子过高
	if !overLoadFactor(h.count+1, h.B) {
		bigger = 0
		h.flags |= sameSizeGrow
	}
	oldbuckets := h.buckets
    // 进行数据扩容
    // 1. 创建新桶和溢出桶
    // 2. 设置oldbuckets和buckets 值
	// 为新桶分配内存
    newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)
    // 扩容倍数
	h.B += bigger
	h.flags = flags
    // 设置新旧桶
	h.oldbuckets = oldbuckets
	h.buckets = newbuckets
	h.nevacuate = 0
	h.noverflow = 0

	h.extra.oldoverflow = h.extra.overflow
	h.extra.overflow = nil
	h.extra.nextOverflow = nextOverflow
}

// 进行数据桶数据迁移，将数据迁移到新桶中
// 将一个旧桶中的数据分流到两个新桶，所以它会创建两个用于保存分配上下文的 runtime.evacDst 结构体，这两个结构体分别指向了一个新桶：
// map 扩容函数
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
		}
	}
}

var sharedVar int32

// Writer
go func() {
   atomic.StoreInt32(&sharedVar, 10)
}()

// Reader
go func() {
   fmt.Println(atomic.LoadInt32(&sharedVar))
}()

type RWMutex struct {
	w           Mutex    // 统一写锁
	writerSem   uint32   // 写等待信号
	readerSem   uint32   // 读等待信号
	readerCount int32    // 当前正在执行的读操作统计
	readerWait  int32    // 当写操作被阻塞时等待的读操作个数；
}

// 写锁
func (rw *RWMutex) Lock() {
    // 1. 持有写锁
	rw.w.Lock()
    // 2. 阻塞读操作
    // 2.1 将读者设置为负数--避免新增读者
    // 2.2 统计当前读者数量
	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
    // 3. 存在其它正在读的--等待其释放
	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
        // 等待writerSem信号将其唤醒
		runtime_SemacquireMutex(&rw.writerSem, false, 0)
	}
    // 成功持有返回
}

// 解除写锁
func (rw *RWMutex) Unlock() {
    // 函数将 readerCount 变回正数，释放读锁；
	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
	if r >= rwmutexMaxReaders {
		throw("sync: Unlock of unlocked RWMutex")
	}
    // 遍历读者
	for i := 0; i < int(r); i++ {
		// 发送信号，唤醒对应读者
        runtime_Semrelease(&rw.readerSem, false, 0)
	}
	rw.w.Unlock()
}


// 读锁
func (rw *RWMutex) RLock() {
    // 当前读者数++&&检查是否存在写者
	if atomic.AddInt32(&rw.readerCount, 1) < 0 {
        // 为负数表示存在写入，需要等待锁释放
        // 休眠等待读锁信号
		runtime_SemacquireMutex(&rw.readerSem, false, 0)
	}
}

// 解除读锁
func (rw *RWMutex) RUnlock() {
    // 减少读者数目
	if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
		// 返回负数 — 其他 Goroutine 获得了写锁
        // 进行读锁慢释放
        rw.rUnlockSlow(r)
	}
}

func (rw *RWMutex) rUnlockSlow(r int32) {
	if r+1 == 0 || r+1 == -rwmutexMaxReaders {
		throw("sync: RUnlock of unlocked RWMutex")
	}
    // 减少读者等待数 && 判断是否没有读者
	if atomic.AddInt32(&rw.readerWait, -1) == 0 {
        // 唤醒写者进行工作
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

package main

import (
	"log"
	"time"

	"github.com/Jeffail/tunny"
)

func main() {
    // 创建一个大小为三的协程池
    // 并定义函数
	pool := tunny.NewFunc(3, func(i interface{}) interface{} {
		log.Println(i)
		time.Sleep(time.Second)
		return nil
	})
    // 关闭对应协程池
	defer pool.Close()
    // 将参数i传递给协程池定义好的worker处理
	for i := 0; i < 10; i++ {
		go pool.Process(i)
	}
    // 等待一段时间
	time.Sleep(time.Second * 4)
}

func main() {
	defer errorHandler()
	go func() {
		for true {
			fmt.Println("alive")
			time.Sleep(time.Second*1)
			select {}
		}
	}()
	<-make(chan int)
}

// fatal error: all goroutines are asleep - deadlock!

type sig struct{}
 
// 定义基础执行函数
type f func() error
 
// Pool accept the tasks from client,it limits the total
// of goroutines to a given number by recycling goroutines.
// 协程池
type Pool struct {
	// capacity of the pool.
	capacity int32  // 支持容量
 
	// running is the number of the currently running goroutines.
	running int32  // 当前运行的数量
 
	// expiryDuration set the expired time (second) of every worker.
	expiryDuration time.Duration  // 每个worker的过期时间
 
	// workers is a slice that store the available workers.
	workers []*Worker // 运行队列
 
	// release is used to notice the pool to closed itself.
	release chan sig     // 是否释放
 
	// lock for synchronous operation.
	lock sync.Mutex // 异步锁，用于提交队列
 
	once sync.Once  // 用于执行一次
}

// NewPool generates a instance of ants pool
func NewPool(size int) (*Pool, error) {
	return NewTimingPool(size, DefaultCleanIntervalTime)
}
 
// NewTimingPool generates a instance of ants pool with a custom timed task
func NewTimingPool(size, expiry int) (*Pool, error) {
	if size <= 0 {
		return nil, ErrInvalidPoolSize
	}
	if expiry <= 0 {
		return nil, ErrInvalidPoolExpiry
	}
    // 初始化默认pool 
	p := &Pool{
		capacity:       int32(size),
		freeSignal:     make(chan sig, math.MaxInt32),
		release:        make(chan sig, 1),
		expiryDuration: time.Duration(expiry) * time.Second,  // 设置超时时间
	}
	// 启动定期清理过期worker任务，独立goroutine运行，
	// 进一步节省系统资源
	p.monitorAndClear()
	return p, nil
}

// Submit submit a task to pool
func (p *Pool) Submit(task f) error {
	if len(p.release) > 0 {
		return ErrPoolClosed
	}
	w := p.getWorker()
    // 将任务写入到worker中
	w.task <- task
	return nil
}

// getWorker returns a available worker to run the tasks.
func (p *Pool) getWorker() *Worker {
	var w *Worker
	// 标志变量，判断当前正在运行的worker数量是否已到达Pool的容量上限
	waiting := false
	// 加锁，检测队列中是否有可用worker，并进行相应操作
	p.lock.Lock()
	idleWorkers := p.workers
	n := len(idleWorkers) - 1
	// 当前队列中无可用worker
	if n < 0 {
		// 判断运行worker数目已达到该Pool的容量上限，置等待标志
		waiting = p.Running() >= p.Cap()
  
	// 当前队列有可用worker，从队列尾部取出一个使用
	} else {
		w = idleWorkers[n]
		idleWorkers[n] = nil
		p.workers = idleWorkers[:n]
	}
	// 检测完成，解锁
	p.lock.Unlock()
	// Pool容量已满，新请求等待
	if waiting {
		// 利用锁阻塞等待直到有空闲worker
		for {
			p.lock.Lock()
			idleWorkers = p.workers
			l := len(idleWorkers) - 1
			if l < 0 {
				p.lock.Unlock()
				continue
			}
			w = idleWorkers[l]
			idleWorkers[l] = nil
			p.workers = idleWorkers[:l]
			p.lock.Unlock()
			break
		}
	// 当前无空闲worker但是Pool还没有满，
	// 则可以直接新开一个worker执行任务
	} else if w == nil {
		w = &Worker{
			pool: p,
			task: make(chan f, 1),
		}
		w.run()
        // 运行worker数加一
		p.incRunning()
	}
	return w
}

// worker 回收 
func (p *Pool) putWorker(worker *Worker) {
	// 写入回收时间，亦即该worker的最后一次结束运行的时间
	worker.recycleTime = time.Now()
	p.lock.Lock()
	p.workers = append(p.workers, worker)
	p.lock.Unlock()
}

// ReSize change the capacity of this pool
func (p *Pool) ReSize(size int) {
	if size == p.Cap() {
		return
	}
	atomic.StoreInt32(&p.capacity, int32(size))
	diff := p.Running() - size
	if diff > 0 {
		for i := 0; i < diff; i++ {
			p.getWorker().task <- nil
		}
	}
}

// 清理过期worker
// clear expired workers periodically.
func (p *Pool) periodicallyPurge() {
	heartbeat := time.NewTicker(p.expiryDuration)
	for range heartbeat.C {
		currentTime := time.Now()
		p.lock.Lock()
		idleWorkers := p.workers
		if len(idleWorkers) == 0 && p.Running() == 0 && len(p.release) > 0 {
			p.lock.Unlock()
			return
		}
		n := 0
		for i, w := range idleWorkers {
			if currentTime.Sub(w.recycleTime) <= p.expiryDuration {
				break
			}
			n = i
			w.task <- nil
			idleWorkers[i] = nil
		}
		n++
		if n >= len(idleWorkers) {
			p.workers = idleWorkers[:0]
		} else {
			p.workers = idleWorkers[n:]
		}
		p.lock.Unlock()
	}
}

// Worker is the actual executor who runs the tasks,
// it starts a goroutine that accepts tasks and
// performs function calls.
type Worker struct {
	// pool who owns this worker.
	pool *Pool
 
	// task is a job should be done.
	task chan f
 
	// recycleTime will be update when putting a worker back into queue.
	recycleTime time.Time
}
 
// run starts a goroutine to repeat the process
// that performs the function calls.
func (w *Worker) run() {
	go func() {
		// 循环监听任务列表，一旦有任务立马取出运行
		for f := range w.task {
			if f == nil {
                // 退出goroutine，运行worker数减一
				w.pool.decRunning()
				return
			}
			f()
			// worker回收复用
			w.pool.putWorker(w)
		}
	}()
}

// 字符串截取内存泄漏
func main() {
 var str0 = "12345678901234567890"
 str1 := str0[:10]
}

// 切片截取引起子切片内存泄漏
func main() {
   var s0 = []int{0,1,2,3,4,5,6,7,8,9}
   s1 := s0[:3]
}

package main

import "fmt"

func main() {

    var name string
    var age int

    /*
        使用"&"获取score变量的内存地址(即取变量内存地址的运算符)，通过键盘输入为score变量指向的内存地址赋初值。

        fmt.Scan是一个阻塞的函数，如果它获取不到数据就会一直阻塞哟。

        fmt.Scan可以接收多个参数，用户输入参数默认使用空格或者回车换行符分割输入设备传入的参数，直到接收所有的参数为止
    */
    fmt.Scan(&name, &age)
    fmt.Println(name, age)

    /*
        和fmt.Scan功能类似，fmt.Scanln也是一个阻塞的函数，如果它获取不到数据就会一直阻塞哟。

        fmt.Scanln也可以接收多个参数，用户输入参数默认使用空格分割输入设备传入的参数，遇到回车换行符就结束接收参数
    */
    fmt.Scanln(&name, &age)
    fmt.Println(name, age)

     /*
        和fmt.Scanln功能类似，fmt.Scanf也是一个阻塞的函数，如果它获取不到数据就会一直阻塞哟。

        其实fmt.Scanln和fmt.Scanf可都以接收多个参数，用户输入参数默认使用空格分割输入设备传入的参数，遇到回车换行符就结束接收参数

        唯一区别就是可以格式化用户输入的数据类型,如下所示:
            %s:
                表示接收的参数会被转换成一个字符串类型，赋值给变量
            %d:
                表示接收的参数会被转换成一个整形类型，赋值给变量

        生产环境中使用fmt.Scanln和fmt.Scanf的情况相对较少，一般使用fmt.Scan的情况较多~
    */
    fmt.Scanf("%s%d", &name, &age)
    fmt.Println(name, age)
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

input := bufio.NewScanner(os.Stdin)
for input.Scan() {
    data := input.Text()
}   

package main
import (
    "bufio"
    "fmt"
    "os"
)
var inputReader *bufio.Reader
var input string
var err error
func main() {
    inputReader = bufio.NewReader(os.Stdin)
    fmt.Println("Please enter some input: ")
    input, err = inputReader.ReadString('S') //func (b *Reader) ReadString(delim byte) (line string, err error) ,‘S’ 这个例子里使用S表示结束符，也可以用其它，如'\n'
    if err == nil {
        fmt.Printf("The input was: %s\n", input)
    }
}

// Please enter some input:
// abcd
// 
// abc
// S
// The input was: abcd
//
// abc
// S

package main

import (
    "fmt"
    "io"
)

func main() {
    var a, b int
    for {
        _, err := fmt.Scan(&a, &b)
        if err == io.EOF {
            break
        }
        fmt.Println(a + b)
    }
}
// input
// 1 2
// 1 2
// out 
// 3
// 3

package main

import "fmt"

func main() {
    var n, a, b int
    fmt.Scan(&n)
    for i := 0; i < n; i++ {
        fmt.Scan(&a, &b)
        fmt.Println(a + b)
    }
}

package main

import "fmt"

func main() {
    var a, b int
    for {
        fmt.Scan(&a, &b)
        if a == 0 && b == 0 {
            break
        }
        fmt.Println(a + b)
    }
}

package main

import "fmt"

func main() {
    var n, a int
    for {
        fmt.Scan(&n)
        if n == 0 {
            break
        }
        sum := 0
        for i := 0; i < n; i++ {
            fmt.Scan(&a)
            sum += a
        }
        fmt.Println(sum)
    }
}

package main

import (
    "fmt"
    "io"
)

func main() {
    var n, a int
    for {
        // 读取首行n
        _, err := fmt.Scan(&n)
        if err == io.EOF {
            break
        }
        sum := 0
        for i := 0; i < n; i++ {
            fmt.Scan(&a)
            sum += a
        }
        fmt.Println(sum)
    }
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    // 获取输入
    inputs := bufio.NewScanner(os.Stdin)
    // 循环直到读取到EOF
    for inputs.Scan() {  //每次读入一行
        data := strings.Split(inputs.Text(), " ")  //通过空格将他们分割，并存入一个字符串切片
        var sum int
        for i := range data {
            val, _ := strconv.Atoi(data[i])   //将字符串转换为int
            sum += val
        }
        fmt.Println(sum)
    }
}

package main

import(
    "fmt"
    "os"
    "bufio"
    "sort"
    "strings"
)
 
func main(){
    in := bufio.NewScanner(os.Stdin)
    in.Scan()
    for in.Scan(){
        str := in.Text()
        s := strings.Split(str, " ")
        sort.Strings(s)  //排序
        fmt.Println(strings.Join(s," "))  //将切片连接成字符串
    }
}