4个场景教会你Go中Goroutine和通道是怎么用的

package main

import (
 "fmt"
 "sync"
)

// 服务器结构体
type Server struct {
 Name string
 // 其他服务器相关的字段
}

// 执行任务的函数
func executeTask(server Server, task string) {
 // 连接服务器并执行任务的逻辑
 fmt.Printf("执行任务 [%s] 到服务器 [%s]\n", task, server.Name)
 // 执行操作的代码
}

func main() {
 // 服务器列表
 servers := []Server{
  {Name: "Server1"},
  {Name: "Server2"},
  {Name: "Server3"},
  // 添加更多的服务器
 }

 // 任务列表
 tasks := []string{"部署应用程序", "更新配置", "执行命令", "其他任务"}

 // 创建一个任务通道，用于发送任务到Goroutine池
 taskChannel := make(chan string)

 // 创建一个等待组，用于等待所有Goroutine执行完毕
 var wg sync.WaitGroup
 wg.Add(len(servers))

 // 启动Goroutine池
 for _, server := range servers {
  go func(server Server) {
   // 标记任务完成时，通知等待组减少一个计数
   defer wg.Done()

   // 从任务通道中接收任务，并执行
   for task := range taskChannel {
    executeTask(server, task)
   }
  }(server)
 }

 // 将任务发送到任务通道
 for _, task := range tasks {
  taskChannel <- task
 }

 // 关闭任务通道，表示所有任务都已发送
 close(taskChannel)

 // 等待所有Goroutine执行完毕
 wg.Wait()
}

package main

import (
 "fmt"
 "log"
 "os"
 "sync"
)

// 日志结构体
type Log struct {
 Message string
 // 其他日志相关的字段
}

func main() {
 // 创建一个日志通道，用于发送日志数据
 logChannel := make(chan Log)

 // 创建一个等待组，用于等待所有Goroutine执行完毕
 var wg sync.WaitGroup

 // 启动一个Goroutine处理日志写入操作
 wg.Add(1)
 go func() {
  // 标记日志写入完毕时，通知等待组减少一个计数
  defer wg.Done()

  // 打开文件进行日志写入
  file, err := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
  if err != nil {
   log.Fatal(err)
  }
  defer file.Close()

  // 创建一个日志写入器
  logger := log.New(file, "", log.LstdFlags)

  // 从日志通道中接收日志数据，并写入到目标中
  for log := range logChannel {
   logger.Println(log.Message)
  }
 }()

 // 并发地向日志通道发送日志数据
 for i := 0; i < 10; i++ {
  wg.Add(1)
  go func(index int) {
   // 标记发送完日志数据时，通知等待组减少一个计数
   defer wg.Done()

   // 构造日志数据
   log := Log{
    Message: fmt.Sprintf("日志消息 %d", index),
    // 设置其他日志字段
   }

   // 发送日志数据到日志通道
   logChannel <- log
  }(i)
 }

 // 关闭日志通道，表示所有日志数据都已发送
 close(logChannel)

 // 等待日志写入操作的Goroutine执行完毕
 wg.Wait()
}

package main

import (
 "fmt"
 "time"
)

// 执行任务的函数
func executeTask(task string) {
 // 执行任务的逻辑
 fmt.Println("执行任务:", task)
 // 具体的任务操作代码
}

func main() {
 // 创建一个定时器，每隔一段时间触发一次
 timer := time.NewTimer(5 * time.Second)

 // 启动一个Goroutine等待定时器的触发事件
 go func() {
  // 等待定时器的触发事件
  <-timer.C
  // 定时器触发后执行任务
  executeTask("定时任务1")
  // 重新设置定时器，以实现循环调度
  timer.Reset(10 * time.Second)
 }()

 // 主线程继续执行其他任务
 // ...

 // 阻塞主线程，保持程序运行
 select {}
}

package main

import (
 "fmt"
 "time"
)

// 任务结构体
type Task struct {
 ID   int
 Data string
 // 其他任务相关的字段
}

// 生产者，负责生产任务并发送到通道
func producer(ch chan<- Task) {
 for i := 1; i <= 10; i++ {
  task := Task{
   ID:   i,
   Data: fmt.Sprintf("任务 %d", i),
   // 设置其他任务字段
  }
  ch <- task
  fmt.Println("生产任务:", task.Data)
  time.Sleep(500 * time.Millisecond) // 模拟生产任务的耗时
 }
 close(ch) // 关闭通道，表示所有任务都已生产完毕
}

// 消费者，负责从通道接收任务并进行处理
func consumer(ch <-chan Task) {
 for task := range ch {
  fmt.Println("消费任务:", task.Data)
  // 执行任务的处理逻辑
  time.Sleep(1 * time.Second) // 模拟处理任务的耗时
 }
}

func main() {
 // 创建一个任务通道，用于生产者和消费者之间的通信
 taskChannel := make(chan Task)

 // 启动生产者Goroutine
 go producer(taskChannel)

 // 启动多个消费者Goroutine
 for i := 1; i <= 3; i++ {
  go consumer(taskChannel)
 }

 // 阻塞主线程，保持程序运行
 select {}
}