func main() {
	wg := sync.WaitGroup{}
	ch := make(chan int, 10)
	for i := 0; i < 10; i++ {
		ch <- i // put task into channel
	}

	close(ch)

	wg.Add(4)
	for j := 0; j < 4; j++ {
		go func() {
			for {
				task := <-ch
				// do sth
				fmt.Println(task)
			}
			wg.Done()
		}()
	}
	wg.Wait()
}

func main() {
	// ... ...
	handler()
	// ... ...
}

func handler() {
	ch := make(chan string)
	go func() {
		// do sth then put result
		time.Sleep(3 * time.Second)
		ch <- "job result"
	}()

	select {
	case result := <-ch:
		fmt.Println(result)
	case <-time.After(time.Second): //timeout
		return
	}
}

func main() {
	var (
		wg  sync.WaitGroup
		ch  = make(chan int64, 1)
		res int64
	)
	wg.Add(2)
	go func() {
		defer wg.Done()
		ch <- 4
		// do sth
		fmt.Println(atomic.LoadInt64(&res))
	}()
	go func() {
		defer wg.Done()
		// do sth
		atomic.AddInt64(&res, <-ch)
	}()
	wg.Wait()
	close(ch)
}

func main() {
	var (
		l  sync.Mutex
		wg sync.WaitGroup
		ch = make(chan int, 1)
	)
	wg.Add(2)
	go func() {
		defer wg.Done()
		l.Lock()
		for i := 0; i < 4; i++ {
			ch <- i
		}
		l.Unlock()
	}()
	go func() {
		defer wg.Done()
		for a := range ch {
			l.Lock()
			fmt.Println(a)
			l.Unlock()
		}

	}()
	wg.Wait()
	close(ch)
}

type hchan struct {
	qcount   uint           // 当前队列中剩余元素个数，即len
	dataqsiz uint           // 环形队列长度，即可以存放的元素个数，cap
	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              // 该锁保护hchan所有字段
}

func do(i int) error {
	if i < 0 {
		return errors.New("")
	}
	return nil
}
func main() {
	var l sync.Mutex
	l.Lock()
	if do(4) != nil {
		fmt.Println("have err")
		return
	}
	l.Unlock()
}

func main() {
	var (
		wg sync.WaitGroup
		mu sync.RWMutex
	)

	wg.Add(5)
	go func() {
		defer wg.Done()
		mu.RLock()
		time.Sleep(5 * time.Second)
		mu.RUnlock()
	}()
	time.Sleep(time.Second)
	// 加写锁，此时reader0还未释放锁
	go func() {
		defer wg.Done()
		fmt.Println("writer0 Call Lock")
		mu.Lock()
		fmt.Println("writer0 Lock")
		time.Sleep(5 * time.Second)
		fmt.Println("writer0 Call UnLock")
		mu.Unlock()
		fmt.Println("writer0 UnLocked")
	}()
	time.Sleep(time.Second)
	// 加读锁，此时reader0还未释放锁
	for i := 1; i <= 3; i++ {
		go func(idx int) {
			defer wg.Done()
			fmt.Printf("reader%d Call RLock\n", idx)
			mu.RLock()
			fmt.Printf("reader%d RLock\n", idx)
			time.Sleep(3 * time.Second)
			fmt.Printf("reader%d Call RUnLock\n", idx)
			mu.RUnlock()
			fmt.Printf("reader%d RUnLocked\n", idx)
		}(i)
	}
	wg.Wait()
}

var mu sync.RWMutex

func main() {
	go A1()
	time.Sleep(2 * time.Second)

	fmt.Println("w call lock")
	mu.Lock()
	defer mu.Unlock()

}
func A1() {
	fmt.Println("a1 call rlock")
	mu.RLock()
	fmt.Println("a1 rlocked")
	defer mu.RUnlock()
	B2()
}
func B2() {
	time.Sleep(5 * time.Second)
	C3()
}
func C3() {
	fmt.Println("c3 call rlock")
	mu.RLock()
	fmt.Println("c3 rlocked")
	defer mu.RUnlock()
}

func main() {
    var sm sync.Map
    for i := 0; i < 1 << 26; i++ {
        var value [1000]int
        value[0] = i
        sm.Store(value, i)
        if i > 0 {
          sm.Delete(value)
        }
    }
}

func main() {
	count := 0
	once := sync.Once{}
	go func() {
		defer func() {
			if e := recover(); e != nil {
				fmt.Println("recovered from once")
			}
		}()
		once.Do(func() {
			fmt.Println("once in goroutine")
			count = 1 / count
		})
	}()
	
	time.Sleep(time.Second)
	once.Do(func() {
		fmt.Println("once in main")
		count = 1 / count
	})
	fmt.Println("end")
}

func main() {
	var wg sync.WaitGroup
	var count int64
	for i := 0; i < 1000; i++ {
		go func() {
			wg.Add(1)
			atomic.AddInt64(&count, 1) // do sth
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Printf("done! count:%v\n", atomic.LoadInt64(&count))
}

func main() {
	m := sync.Mutex{}
	c := sync.NewCond(&m)
	go func() {
		time.Sleep(1 * time.Second)
		c.Broadcast()
	}()
	c.L.Lock()
	time.Sleep(2 * time.Second)
	c.Wait()
	c.L.Unlock()
}

func main() {
	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()
		start := time.Now()
		defer fmt.Printf("logging job cost: %v\n", time.Since(start))
		fmt.Printf("logging at job start: %v\n", start)
		// do sth
		time.Sleep(time.Second)
	}()
	wg.Wait()
	time.Sleep(time.Second)
}

func main() {
	i := 1
	j := add(&i)
	fmt.Println("i :", i)
	fmt.Println("j :", j)
}

func add(n *int) int {
	defer func() {
		*n = *n + 1
	}()
	return *n
}

// Case-13
func main() {
	fmt.Println(fn())
}
func fn() (n int) {
	defer func() {
		n += n
	}()
	n = 1
	return n
}

func main() {
	var wg sync.WaitGroup
	wg.Add(3)
	for i := 0; i < 3; i++ {
		go func() {
			defer wg.Done()
			fmt.Println(i)
		}()
	}
	wg.Wait()
}

func main() {
    v1 := 1
    if v1 == 1 {
        v1, v2 := 2, 3
        fmt.Println("Inner:", v1, v2)
    }
    fmt.Println("Outer:", v1)
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		time.Sleep(5 * time.Second)
		cancel()
	}()
	isTimeout := false
Loop:
	for {
		select {
		case <-ctx.Done():
			break Loop
		case <-time.After(time.Second * 2):
			isTimeout = true
			break Loop
		default:
			// do sth
		}
	}
	fmt.Printf("end with timeout: %v\n", isTimeout)
}

{
    "go.autocompleteUnimportedPackages": true,
    "go.useCodeSnippetsOnFunctionSuggest": true,
    "go.useCodeSnippetsOnFunctionSuggestWithoutType": true,
    "go.useLanguageServer": true,
}

func main() {
	listen, err := net.Listen("tcp", ":2333")
	if err != nil {
		log.Println("listen error: ", err)
		return
	}
	defer listen.Close()

	for {
		conn, err := listen.Accept()
		if err != nil {
			log.Println("accept error: ", err)
			break
		}
		go echo(conn)
	}
}

func echo(conn net.Conn) {
	defer conn.Close()
	dt := make([]byte, 1024)
	// 如果没有数据读取将阻塞
	n, err := conn.Read(dt)
	if err != nil {
		log.Println("read socket error: ", err)
		return
	}
	// 如果连接不可写将阻塞
	_, _ = conn.Write(dt[:n])
}

// net/fd_posix.go
// Network file descriptor.
type netFD struct {
	pfd poll.FD

	// immutable until Close
	family      int
	sotype      int
	isConnected bool // handshake completed or use of association with peer
	net         string
	laddr       Addr
	raddr       Addr
}

// internal/poll/fd_unix.go
type FD struct {
    // 省略了很多其他字段

    // 系统文件描述符
	// System file descriptor. Immutable until Close.
	Sysfd int

	// 读写超时等操作都是通过调用pollDesc对应方法实现的
	// I/O poller.
	pd pollDesc

}

type pollDesc struct {
    // 指向runtime/netpoll.go中的pollDesc类型的指针
	runtimeCtx uintptr
}

type pollDesc struct {
	link *pollDesc // in pollcache, protected by pollcache.lock

	// The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
	// This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
	// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO readiness notification)
	// proceed w/o taking the lock. So closing, everr, rg, rd, wg and wd are manipulated
	// in a lock-free way by all operations.
	// NOTE(dvyukov): the following code uses uintptr to store *g (rg/wg),
	// that will blow up when GC starts moving objects.
	lock    mutex // protects the following fields
	fd      uintptr
	closing bool
	everr   bool      // marks event scanning error happened
	user    uint32    // user settable cookie
	rseq    uintptr   // protects from stale read timers
	rg      uintptr   // pdReady, pdWait, G waiting for read or nil
	rt      timer     // read deadline timer (set if rt.f != nil)
	rd      int64     // read deadline
	wseq    uintptr   // protects from stale write timers
	wg      uintptr   // pdReady, pdWait, G waiting for write or nil
	wt      timer     // write deadline timer
	wd      int64     // write deadline
	self    *pollDesc // storage for indirect interface. See (*pollDesc).makeArg.
}

func poll_runtime_pollWait(pd *pollDesc, mode int) int {
	errcode := netpollcheckerr(pd, int32(mode))
	if errcode != pollNoError {
		return errcode
	}
	// As for now only Solaris, illumos, and AIX use level-triggered IO.
	if GOOS == "solaris" || GOOS == "illumos" || GOOS == "aix" {
		netpollarm(pd, mode)
	}
	// 进入netpollblock并且判断是否有期待的 I/O 事件发生
	// 此处for循环是为了一直等待io ready
	for !netpollblock(pd, int32(mode), false) {
		errcode = netpollcheckerr(pd, int32(mode))
		if errcode != pollNoError {
			return errcode
		}
		// Can happen if timeout has fired and unblocked us,
		// but before we had a chance to run, timeout has been reset.
		// Pretend it has not happened and retry.
	}
	return pollNoError
}

func netpollblock(pd *pollDesc, mode int32, waitio bool) bool {
	gpp := &pd.rg
	if mode == 'w' {
		gpp = &pd.wg
	}

	// set the gpp semaphore to pdWait
	// 这个 for 循环是为了等待 io ready 或者将状态设置为io wait
	for {
		old := *gpp
		if old == pdReady {
			*gpp = 0
			return true
		}
		if old != 0 {
			throw("runtime: double wait")
		}
		if atomic.Casuintptr(gpp, 0, pdWait) {
			break
		}
	}

	// waitio此时为false，并且pollDesc一般都是正常的，所以会调用gopark将当前的goroutine
	// park住，直到对应的fd上发生可读/可写或者其其他i/o事件
	// 在gopark内部会将当前的gorutine指针赋值给gpp(pollDesc.rg/pollDesc.wg) 
	// 同时将gorutine状态置为waiting
	// 后需当io就绪后取出注册到epoll实例中的数据pollDesc，并将pollDesc中等待i/o的g
	// 放回调度链表重新调度
	if waitio || netpollcheckerr(pd, mode) == 0 {
		gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceEvGoBlockNet, 5)
	}
	// be careful to not lose concurrent pdReady notification
	old := atomic.Xchguintptr(gpp, 0)
	if old > pdWait {
		throw("runtime: corrupted polldesc")
	}
	return old == pdReady
}

func netpoll(delay int64) gList {
    // 省略代码
	var events [128]epollevent
retry:
    // 无阻塞查看epoll实例上是否i/o就绪的fd
	n := epollwait(epfd, &events[0], int32(len(events)), waitms)
	// 省略代码
	// 存储要恢复的 goroutines，最后返回给调用方
	var toRun gList
	for i := int32(0); i < n; i++ {
		ev := &events[i]
		if ev.events == 0 {
			continue
		}
		// 省略代码
		// 判断发生的事件类型，读类型或者写类型等，然后给 mode 复制相应的值，
        // mode 用来决定从 pollDesc 里的 rg 还是 wg 里取出 goroutine
		var mode int32
		if ev.events&(_EPOLLIN|_EPOLLRDHUP|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'r'
		}
		if ev.events&(_EPOLLOUT|_EPOLLHUP|_EPOLLERR) != 0 {
			mode += 'w'
		}
		if mode != 0 {
		    // 取出保存在 epollevent 里的 pollDesc
			pd := *(**pollDesc)(unsafe.Pointer(&ev.data))
			pd.everr = false
			if ev.events == _EPOLLERR {
				pd.everr = true
			}
			// 调用 netpollready，传入就绪 fd 的 pollDesc，
            // 把 fd 对应的 goroutine 添加到链表 toRun 中
			netpollready(&toRun, pd, mode)
		}
	}
	return toRun
}