// An anonymous function method is used to start the thread.
go func() {
	for i := 0; i < 10; i++ {
		fmt.Println("Hello World!")
	}
}()

func SafeGo(do func())  {
	go func() {
		defer func() {
			// catch panic in do() avoid crash
			if err := recover(); err != nil {
				fmt.Println(fmt.Sprintf("panic %s\n", err))
				fmt.Println(fmt.Sprint(string(debug.Stack())))
			}
		}()
		do()
	}()
}

// It can get the current number of logical processors.
now := GOMAXPROCS(-1)

type hchan struct {
	qcount   uint
	dataqsiz uint
	buf      unsafe.Pointer
	// points to an array of dataqsiz elements
	elemsize uint16
	closed   uint32
	elemtype *_type
	sendx    uint
	recvx    uint
	recvq    waitq
	sendq    waitq
	// Lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	lock mutex
}

// The channel of work task class has buffer.
jobs := make(chan int, 10)
// Notification channel has no buffer.
done := make(chan bool)

func Work(jobs <-chan *job done chan<- bool) {}
// Read or write according to the direction of the arrow.

case data := <-ch1:
  // code...
case data := <-ch2:
  // code...
default:
  // code...

var done chan struct{}
func random(done chan struct{}) chan int {
	ch := make(chan int, 10)
label:
	for {
		num, _ := rand.Int()
		select {
		case ch <- num:
		case <-done:
			// jump out of code snippet
			break label
		}
	}
	return ch
}
func main() {
	done := make(chan struct{}, 1)
	ch := random(done)
	// put the data to the channal
	done <- struct{}{}
	close(done)
}

func GeneratorIntA(done chan struct{}) chan int {
	ch := make(chan int, 10)
	go func() {
	label:
		for {
			// stop by listening for a signal
			select {
			case ch <- rand.Int():
			case <-done:
				break label
			}
		}
		close(ch)
	}()
	return ch
}
func GeneratorIntB(done chan struct{}) chan int {
	ch := make(chan int, 10)
	go func() {
	label:
		for {
			// stop by listening for a signal
			select {
			case ch <- rand.Int():
			case <-done:
				break label
			}
		}
		close(ch)
	}()
	return ch
}
func GeneratorInt(done chan struct{}) chan int {
	ch := make(chan int, 20)
	go func() {
	Label:
		for {
			select {
			// total generator multiplexing
			case ch <- <-GeneratorIntA(done):
			case ch <- <-GeneratorIntB(done):
			case <-done:
				break Label
			}
		}
		close(ch)
	}()
	return ch
}
func main() {
	done := make(chan struct{})
	ch := GeneratorInt(done)
	for i := 0; i < 10; i++ {
		fmt.Println(<-ch)
	}
	done <- struct{}{}
	fmt.Println("stop generator")
}

func Chain(in chan int) chan int {
	out := make(chan int)
	go func() {
		for v := range in {
			out <- v + 1
		}
		close(out)
	}()
	return out
}
func main() {
	in := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			in <- i
		}
		close(in)
	}()
	// equivalent to a batch process
	out := Chain(Chain(Chain(in)))
	for v := range out {
		fmt.Println(v)
	}
}

// Server processing request function which use tcp connection.
func HandleFunc(conn *net.TCPConn) {
	defer conn.Close()
	for {
		buf := make([]byte, 256)
		cnt, err := conn.Read(buf)
		if err != nil {
			return
		}
	}
}
func main() {
	localAddr, err := net.ResolveTCPAddr("tcp", "192.168.124.4:8090")
	if err != nil {
		return
	}
	listener, err := net.ListenTCP("tcp", localAddr)
	if err != nil {
		return
	}
	for {
		conn, err := listener.AcceptTCP()
		if err != nil {
			return
		}
		// process connection request
		go HandleFunc(conn)
	}
}

type Task struct {
	ID      int
	randnum int
}
type Result struct {
	task   Task
	result int
}
var tasks = make(chan Task, 10)
var results = make(chan Result, 10)
func Process(num int) int {
	sum := 0
	for num != 0 {
		digit := num % 10
		sum += digit
		num /= 10
	}
	return sum
}
func Worker(wg *WaitGroup) {
	defer wg.Done()
	// Constantly read new task processing from tasks channel.
	for task := range tasks {
		result := Result{task, Process(task.randnum)}
		results <- result
	}
}
func CreateWorkerPool(number int) {
	var wg sync.WaitGroup
	// Construct multiple workers to handle tasks.
	for i := 0; i < number; i++ {
		wg.Add(1)
		go worker(&wg)
	}
	wg.Wait()
	close(results)
}

type Query struct {
	sql    chan string
	result chan string
}
func ExecQuery(q Query) {
	go func() {
		// get input
		sql := <-q.sql
		q.result <- "result from " + sql
	}()
}
func main() {
	q := Query{make(chan string, 1), make(chan string, 1)}
	go ExecQuery(q)
	// Send parameters to the channel.
	q.sql <- "slect * from table"
	// Get results from the channel.
	fmt.Println(<-q.result)
}

func Child(ctx context.Context) {
	for {
		select {
		// The notification exit mechanism is encapsulated.
		case <-ctx.Done():
			return
		default:
			// code...
		}
	}
}
func main() {
	// build a context
	ctx, cancel := context.WithCancel(context.Background())
	go Child(ctx)
	time.Sleep(10 * time.Second)
	cancel()
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
	// Although this context has a time-limited exit, it can also actively call
	// cancel() to exit.
	go func(ctx context.Context) {
		select {
		case <-ctx.Done():
			fmt.Println("Time out")
			return
		default:
			// code...
		}
	}(ctx)
	cancel()
}

func Something(ctx context.Context) {
	v, ok := ctx.Value("key").(string)
	if ok {
		fmt.Println("%v", v)
	}
}
func main() {
	ctx := context.WithValue(context.Background(), "key", "value")
	go Something(ctx)
}

type Context interface {
	// The empty interface channel notification exits.
	Done() <-chan struct{}
	Err() error
	// The deadline for the execution of the task.
	Deadline() (deadline time.Time, ok bool)
	// According to key to get the value stored in context.
	Value(key interface{}) interface{}
}