func main() {
  ...
	if GOARCH != "wasm" { 
     // 系统栈上的函数执行
		systemstack(func() {  
			newm(sysmon, nil, -1) // 用于创建新的 M（机器，代表一个操作系统线程）。
		})
	} 
  ...
}

func sender(ch chan<- int, done chan<- bool) {
	fmt.Println("Sending...")
	ch <- 42 // 发送数据到无缓冲通道
	fmt.Println("Sent")
	done <- true // 发送完成信号
}

func receiver(ch <-chan int, done <-chan bool) {
	<-done // 等待发送操作完成信号
	fmt.Println("Receiving...")
	val := <-ch // 从无缓冲通道接收数据
	fmt.Println("Received:", val)
}

func main() {
	ch := make(chan int) // 创建无缓冲通道
	done := make(chan bool) // 用于发送操作完成信号

	go sender(ch, done)   // 启动发送goroutine
	go receiver(ch, done) // 启动接收goroutine

	time.Sleep(2 * time.Second) // 等待一段时间以观察结果
}

func sender(ch chan<- int) {
	for i := 0; i < 5; i++ {
		fmt.Println("Sending:", i)
		ch <- i // 发送数据到通道
		fmt.Println("Sent:", i)
	}
	close(ch)
}

func receiver(ch <-chan int) {
	for {
		val, ok := <-ch // 从通道接收数据
		if !ok {
			fmt.Println("Channel closed")
			return
		}
		fmt.Println("Received:", val)
		time.Sleep(1 * time.Second) // 模拟接收操作耗时
	}
}

func main() {
	ch := make(chan int, 2) // 创建带缓冲大小为2的通道

	go sender(ch)   // 启动发送goroutine
	go receiver(ch) // 启动接收goroutine

	time.Sleep(10 * time.Second) // 等待一段时间以观察结果
}

// calculateSquare 是一个计算数字平方的函数，它模拟了一个耗时的计算过程。
func calculateSquare(num int, resultChan chan<- int) {
	time.Sleep(1 * time.Second) // 模拟耗时计算
	resultChan <- num * num
}

func main() {
	nums := []int{1, 2, 3, 4, 5}
	resultChan := make(chan int)

	// 启动多个goroutine并发计算数字的平方
	for _, num := range nums {
		go calculateSquare(num, resultChan)
	}

	// 从通道中接收计算结果并打印
	for range nums {
		result := <-resultChan
		fmt.Println("Square:", result)
	}
	close(resultChan)
}

// fetchURL 函数用于获取指定URL的内容，并将结果发送到通道resultChan中。
func fetchURL(url string, resultChan chan<- string) {
	resp, err := http.Get(url)
	if err != nil {
		resultChan <- fmt.Sprintf("Error fetching %s: %s", url, err)
		return
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		resultChan <- fmt.Sprintf("Error reading response from %s: %s", url, err)
		return
	}
	resultChan <- string(body)
}

func main() {
	urls := []string{"https://example.com", "https://example.org", "https://example.net"}
	resultChan := make(chan string)

	// 启动多个goroutine并发获取URL的内容
	for _, url := range urls {
		go fetchURL(url, resultChan)
	}

	// 从通道中接收结果并打印
	for range urls {
		result := <-resultChan
		fmt.Println("Response:", result)
	}
	close(resultChan)
}

// processData 函数用于处理从dataStream中接收的数据，并将处理结果发送到resultChan中。
func processData(dataStream <-chan int, resultChan chan<- int) {
	for num := range dataStream {
		resultChan <- num * 2 // 假设处理数据是将数据乘以2
	}
}

func main() {
	dataStream := make(chan int)
	resultChan := make(chan int)

	// 产生数据并发送到dataStream中
	go func() {
		for i := 1; i <= 5; i++ {
			dataStream <- i
		}
		close(dataStream)
	}()

	// 启动goroutine并发处理数据
	go processData(dataStream, resultChan)

	// 从通道中接收处理结果并打印
	for range dataStream {
		result := <-resultChan
		fmt.Println("Processed Data:", result)
	}
	close(resultChan)
}

// handler 是一个HTTP请求处理函数，它会向客户端发送"Hello, World!"的响应。
func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, World!")
}

func main() {
	// 注册HTTP请求处理函数
	http.HandleFunc("/", handler)

	// 启动HTTP服务器并监听端口8080
	go http.ListenAndServe(":8080", nil)
	fmt.Println("Server started on port 8080")

	// 使用select{}使主goroutine保持运行状态，以便HTTP服务器能够处理请求
	select {}
}

// task 是一个需要定时执行的任务函数。
func task() {
	fmt.Println("Task executed at:", time.Now())
}

func main() {
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()

	// 循环等待定时器的触发并执行任务
	for {
		select {
		case <-ticker.C:
			task()
		}
	}
}

// worker 是一个工作函数，它会从jobs通道中接收任务，并将处理结果发送到results通道中。
func worker(id int, jobs <-chan int, results chan<- int) {
	for job := range jobs {
		fmt.Printf("Worker %d started job %d\n", id, job)
		time.Sleep(1 * time.Second) // 模拟工作时间
		fmt.Printf("Worker %d finished job %d\n", id, job)
		results <- job * 2 // 假设工作的结果是输入的两倍
	}
}

func main() {
	const numJobs = 10
	const numWorkers = 3

	jobs := make(chan int, numJobs)    // 缓冲channel用于发送任务
	results := make(chan int, numJobs) // 用于接收任务结果

	// 启动多个worker goroutine
	var wg sync.WaitGroup
	for i := 1; i <= numWorkers; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			worker(id, jobs, results)
		}(i)
	}

	// 发送任务到jobs channel
	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs) // 关闭jobs channel

	// 等待所有worker完成并收集结果
	go func() {
		wg.Wait()
		close(results)
	}()

	// 从通道中接收处理结果并打印
	for result := range results {
		fmt.Println("Result:", result)
	}
}