高并发和协程通讯

Go语言的高并发和协程通讯是指利用协程（goroutine）和通道（channel）这两种原语，在多个协程之间实现安全可靠的通信机制，从而实现高效、高并发的处理能力。

在Go语言中，协程是一种轻量级的线程，可以在用户态进行创建、销毁和运行，且相比于操作系统线程的创建和销毁更加快速。而通道则是一种用于协程之间通信的机制，它提供了阻塞式读写操作，来保证通信过程的同步性和可靠性。因此，利用这两种原语，我们可以很方便地在多个协程之间进行数据交换和通信。

具体来说，我们可以在一个协程中通过发送操作将数据发送到通道中，然后在另一个协程中通过接收操作从通道中取出数据。在发送和接收过程中，如果通道为空或者已满，则会阻塞当前协程，直到有其他协程进行操作。

例如，下面是一个简单的示例，展示了如何利用协程和通道实现并发计算1~100的和：

go复制代码
func sumWorker(nums []int, resultChan chan int) {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    resultChan <- sum
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    numWorkers := 4
    resultChan := make(chan int)

    for i := 0; i < numWorkers; i++ {
        start := i * len(nums) / numWorkers
        end := (i+1)*len(nums)/numWorkers
        go sumWorker(nums[start:end], resultChan)
    }

    totalSum := 0
    for i := 0; i < numWorkers; i++ {
        totalSum += <-resultChan
    }

    fmt.Printf("The total sum is %d\n", totalSum)
}

在这个例子中，我们首先将需要计算的数字1~10存储在一个切片中，然后创建了4个协程，并将切片拆分成4份分别交给不同的协程计算。每个协程完成计算后，将计算结果通过通道发送到主协程中进行汇总。最后，主协程从通道中接收计算结果并输出总和。

通过上述示例，我们可以看到，利用协程和通道的并发模型，在Go语言中编写并发程序变得更加容易、高效和安全。

假设案例

假设你现在是一家快递公司的调度员，需要为不同的订单分配不同的快递员进行派送，同时保证每个快递员的负载均衡。如果使用串行的方式，即一个订单一个订单地分配给快递员，会导致快递员的工作效率低下，可能造成客户等待时间过长的问题。

为了解决这个问题，我们可以借助 Go 语言的协程（Goroutine）和通道（Channel）特性，实现高并发的派单系统。具体的实现方式如下：

定义订单和快递员的数据结构

 go复制代码type Order struct {
     ID   int
     Size int
 }
 
 type Courier struct {
     ID     int
     Load   int
     Orders []int
 }

创建订单和快递员的队列

 go复制代码orders := make(chan Order)
 couriers := make(chan Courier)

创建订单分配函数，并启动多个协程来处理订单分配任务

 go复制代码func allocateOrders(orders chan Order, couriers chan Courier) {
     for {
         order := <-orders
         courier := <-couriers
 
         // 判断快递员的负载是否已达上限
         if courier.Load+order.Size <= capacity {
             courier.Load += order.Size
             courier.Orders = append(courier.Orders, order.ID)
             couriers <- courier
         } else {
             orders <- order
             couriers <- courier
         }
     }
 }
 
 // 启动多个协程来处理订单分配任务
 for i := 0; i < numWorkers; i++ {
     go allocateOrders(orders, couriers)
 }

创建快递员派单函数，并启动多个协程来处理派单任务

 go复制代码func dispatchOrders(couriers chan Courier) {
     for {
         courier := <-couriers
 
         // 模拟快递员正在派送订单的过程
         time.Sleep(time.Second * time.Duration(dispatchTime))
 
         // 输出快递员的派单信息
         fmt.Printf("Courier %d dispatched orders: %v\n", courier.ID, courier.Orders)
 
         // 重置快递员的负载和订单列表
         courier.Load = 0
         courier.Orders = []int{}
         couriers <- courier
     }
 }
 
 // 启动多个协程来处理派单任务
 for i := 0; i < numCouriers; i++ {
     courier := Courier{ID: i + 1, Load: 0, Orders: []int{}}
     couriers <- courier
     go dispatchOrders(couriers)
 }

在上述代码中，我们使用了 Go 语言的协程（Goroutine）和通道（Channel）特性，可以同时处理多个订单和快递员的任务，从而实现高并发的派单系统。具体的实现方式如下：

订单和快递员之间通过通道（Channel）进行交互，订单被发送到订单队列，快递员被发送到快递员队列；
多个协程从订单队列中接收订单，从快递员队列中接收快递员，进行订单分配操作；
分配完成后，将更改后的快递员信息发送回快递员队列，等待下一个任务；
多个协程从快递员队列中接收快递员，进行派单操作；
模拟快递员正在派送订单的过程，然后输出快递员的派单信息；
重置快递员的负载和订单列表，将更改后的快递员信息发送回快递员队列，等待下一个任务。

通过使用 Go 语言的并发特性，我们可以同时处理多个订单和快递员的任务，提高了系统的处理效率和响应速度。

GO语言高并发和通道通俗案例讲解 ｜ 青训营笔记

高并发和协程通讯

假设案例

GO语言高并发和通道通俗案例讲解｜青训营笔记