go面试汇总 - 技术栈

1：有ABCD4个线程，怎么能保证这4个线程顺序执行

业务场景：打车业务 A线程检查用户的定位是否准确 B匹配附近的司机 C发送订单给司机 D更新客户端已通匹配到司机

下边是AI给出来的几种方案

方案1：

Go 复制代码

func main() {
	var wg sync.WaitGroup
	ch := make(chan struct{}, 1) // 缓冲大小为1的通道
	for i := 1; i <= 4; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			// 等待通道中的信号
			<-ch
			fmt.Printf("协程 %d 执行\n", id)
			time.Sleep(time.Second)
			// 发送信号给下一个协程
			ch <- struct{}{}
		}(i)
	}
	// 启动第一个协程
	ch <- struct{}{}
	wg.Wait()
	fmt.Println("所有协程执行完毕")
}

这是有问题的，只能保证4个线程 1个接一个的执行不能保证A-->B-->C-->D

方案2：

Go 复制代码

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建通道链
    chA := make(chan struct{})
    chB := make(chan struct{})
    chC := make(chan struct{})
    chD := make(chan struct{})

    go func() {
        defer close(chA)
        fmt.Println("A executing")
        time.Sleep(100 * time.Millisecond)
        fmt.Println("A done")
        chA <- struct{}{}
    }()

    go func() {
        defer close(chB)
        <-chA  // 等待A完成
        fmt.Println("B executing")
        time.Sleep(100 * time.Millisecond)
        fmt.Println("B done")
        chB <- struct{}{}
    }()

    go func() {
        defer close(chC)
        <-chB  // 等待B完成
        fmt.Println("C executing")
        time.Sleep(100 * time.Millisecond)
        fmt.Println("C done")
        chC <- struct{}{}
    }()

    go func() {
        defer close(chD)
        <-chC  // 等待C完成
        fmt.Println("D executing")
        time.Sleep(100 * time.Millisecond)
        fmt.Println("D done")
        chD <- struct{}{}
    }()

    <-chD  // 等待所有完成
    fmt.Println("All goroutines executed in order")
}

方案3

Go 复制代码

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var mu sync.Mutex
	cond := sync.NewCond(&mu)
	current := 0

	runInOrder := func(name string, order int) {
		mu.Lock()
		for current != order {
			cond.Wait()
		}
		fmt.Printf("%s executing\n", name)
		time.Sleep(100 * time.Millisecond)
		fmt.Printf("%s done\n", name)
		current++
		cond.Broadcast() // 通知其他条件已满足
		mu.Unlock()
	}

	go runInOrder("A", 0)
	go runInOrder("B", 1)
	go runInOrder("C", 2)
	go runInOrder("D", 3)

	time.Sleep(1 * time.Second)
	fmt.Println("All executed in order")
}