当前位置: 首页> 文旅> 艺术 > 展厅设计公司哪家专业_义乌进货网平台_搜狗收录查询_2024年将爆发新瘟疫

展厅设计公司哪家专业_义乌进货网平台_搜狗收录查询_2024年将爆发新瘟疫

时间:2025/7/9 6:40:03来源:https://blog.csdn.net/l47ronin/article/details/145636613 浏览次数:0次
展厅设计公司哪家专业_义乌进货网平台_搜狗收录查询_2024年将爆发新瘟疫

什么协程

在Go语言中,协程就是一种轻量的线程,是并发编程的单元,由Go来管理,所以在GO层面的协程会更加的轻量、高效、开销更小,并且更容易实现并发编程。

轻量级线程

  1. Go语言中协程(线程)与传统系统层面的线程相比,实在是太轻量了,能小到2kb
  2. 由于协程的轻量特性,可以更高效地利用系统资源。相较于传统的线程,协程的创建和销毁的开销更小,使得程序更具有扩展性和性能优势。

Go自身管理

  1. 在 Go 中,这些工作由运行时系统自动完成。这样我们就可以更专注于业务逻辑,而不必过多关心底层线程管理的细节。

并发的基本单元

  1. 协程是并发编程的基本单元,可以同时执行多个协程,而它们之间的调度和切换由运行时系统负责。
  2. 在程序中更容易实现高效的并发,处理多个任务而无需显式地创建和管理线程。
  3. 使用协程,我们可以轻松地实现并发任务,例如同时处理多个网络请求、执行后台任务等。由于协程的轻量特性,可以创建数千甚至数百万个协程而不会造成系统负担。

使用通道通信

  1. 协程之间可以通过通道进行通信,这是一种在协程之间安全地传递数据和同步操作的机制。通道是一种强大的工具,用于协程之间的协作和数据传递。

协程的基本操作

创建协程

- 语法: `go 函数(函数列表)`
package main  import (  "fmt"  "time")  func Hello() {  fmt.Println("hello world")  
}  func main() {  go Hello()  fmt.Println("hello main")  time.Sleep(10 * time.Second)  
}

协程与主线程是并发执行的。

协程间通行

  • 主要通过channel来实现的
package main  import (  "fmt"  
)  func sendMessage(ch chan string, msg string) {  ch <- msg  
}  func main() {  messagechan := make(chan string)  go sendMessage(messagechan, "Hello World")  msg := <-messagechan  fmt.Println(msg)  
}

协程间的同步

  • 使用sync包来实现的
  • waitgroup 是用来计数信号量的
package main  import (  "fmt"  "sync")  func worker(id int, wg *sync.WaitGroup) {  defer wg.Done()  fmt.Printf("worker %d starting\n", id)  fmt.Printf("worker %d done\n", id)  
}  func main() {  var wg sync.WaitGroup  for i := 1; i <= 10; i++ {  wg.Add(1)  go worker(i, &wg)  }  wg.Wait()  fmt.Printf("all workers done\n")  
}

waitgroup确保主线程等待所有协程完成

协程的错误处理

  • 使用select语句和通道可以实现协程的错误处理
package main  import (  "fmt"  "time")  func dosomething(ch chan string) {  time.Sleep(2 * time.Second)  ch <- "hello world"  
}  func main() {  ch := make(chan string)  go dosomething(ch)  select {  case msg := <-ch:  fmt.Println(msg)  case <-time.After(1 * time.Second):  fmt.Println("timeout")  }  
}

select 语句允许在多个通道操作中选择一个可用的操作,可以用来处理协程的超时等情况。

协程的高级操作

协程池

  • 协程池是一组预先创建的协程,用于执行并发任务,可以避免频繁创建和销毁协程的开销。
  • 使用缓冲通道来实现协程池
package main  import (  "fmt"  "sync")  func worker(id int, jobs <-chan int, results chan<- int) {  for j := range jobs {  fmt.Println("worker", id, "started job", j)  results <- j * 2  }  
}  func main() {  const numJobs = 5  const numWorkers = 3  jobs := make(chan int, numJobs)  results := make(chan int, numJobs)  var wg sync.WaitGroup  for i := 1; i <= numWorkers; i++ {  wg.Add(1)  go func(i int) {  defer wg.Done()  worker(i, jobs, results)  }(i)  }  for j := 1; j <= 5; j++ {  jobs <- j  }  close(jobs)  go func() {  wg.Wait()  close(results)  }()  for result := range results {  fmt.Println("result", result)  }  
}

三个协程形成了协程池,从任务通道 jobs 中获取任务,处理后将结果发送到结果通道 results

超时控制

package main  import (  "fmt"  "time")  func dosomething(ch chan string) {  time.Sleep(2 * time.Second)  ch <- "hello world"  
}  func main() {  ch := make(chan string)  go dosomething(ch)  select {  case msg := <-ch:  fmt.Println(msg)  case <-time.After(1 * time.Second):  fmt.Println("timeout")  }  
}

time.After 创建一个计时器,如果在指定时间内没有从通道 ch 中接收到结果,就会触发超时。

协程的取消

  • 使用 context 包提供的上下文(Context)来实现协程的取消。
package main  import (  "context"  "fmt"    "time")  func doSomething(ctx context.Context, ch chan string) {  select {  case <-ctx.Done():  ch <- "task completed successfully"  case <-time.After(1 * time.Second):  ch <- "task timed out"  }  
}  func main() {  ctx, cancel := context.WithCancel(context.Background())  defer cancel()  ch := make(chan string)  go doSomething(ctx, ch)  time.Sleep(2 * time.Second)  cancel()  result := <-ch  fmt.Println(result)  
}

通过调用 cancel 函数取消协程的执行。

关键字:展厅设计公司哪家专业_义乌进货网平台_搜狗收录查询_2024年将爆发新瘟疫

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: