如何串行完成一些 gorouting

一分耕耘，一分收获！既然都打开这篇《如何串行完成一些 gorouting》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新Golang相关的内容，希望对大家都有所帮助！

我有一个 go 项目示例，试图模拟烘焙 1000 个披萨并发的情况，但烤箱只有 10 个部件来放置披萨。我是这样开发的，但是goroutines陷入僵局。有人会帮忙吗

package main

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

type Material struct {
    material int
    mutex    sync.Mutex
}

var (
    mOven  sync.Mutex
    inOven int
)

func main() {
    rawMaterial := Material{material: 10000}

    var waitGroup sync.WaitGroup

    for i := 0; i < 1000; i++ {
        waitGroup.Add(1)
        go perparePizza(&waitGroup, &rawMaterial, i)

    }
    waitGroup.Wait()
    fmt.Println("finished with remained material:", rawMaterial.material)
}

func perparePizza(wg *sync.WaitGroup, m *Material, num int) {
    defer wg.Done()
    fmt.Println("Preparing Pizza:", num)
    m.mutex.Lock()
    m.material--
    m.mutex.Unlock()
    //  time.Sleep(time.Second * 2)
    var isCooking chan bool
    for {
        ovenManeger(num, isCooking)
        select {
        case <-isCooking:
            putInOven(num)
        default:
            fmt.Println("waiting for accepting cook!", num)
            time.Sleep(time.Second)
        }
    }

    fmt.Printf("Pizza %d is ready \n", num)
}

func ovenManeger(num int, couldPleaseCook chan bool) {
    if inOven < 10 {
        mOven.Lock()
        inOven = inOven + 1
        couldPleaseCook <- true
        mOven.Unlock()
    }
}
func putInOven(num int) {
    fmt.Println("putInOven", num)
    time.Sleep(time.Second * 30)
    mOven.Lock()
    inOven = inOven - 1
    mOven.Unlock()
}

当 10 个烤箱部件出现死锁时，会引发错误

准备披萨：9 准备披萨：0 准备披萨：1 准备披萨：2 准备披萨：3 准备披萨：4 准备披萨：5 准备披萨：6 准备披萨：7 准备披萨：8 致命错误：所有 goroutine 都在睡觉 - 死锁！

正确答案

我是这样改的，但我认为也会有更好的解决方案。

package main

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

type Material struct {
    material int
    mutex    sync.RWMutex
}

var readValue = make(chan int)
var writeValue = make(chan int)

func set(newValue int) {
    writeValue <- newValue
}

func read() int {
    return <-readValue
}

func backing() {
    var value int
    var internalCounter int
    for {
        select {
        case newValue := <-writeValue:
            internalCounter = internalCounter + 1
            value = newValue
            putInOven(value)

        case readValue <- value:
            internalCounter = internalCounter - 1
        }
    }
}
func main() {
    rawMaterial := Material{material: 10000}

    var waitGroup sync.WaitGroup

    for i := 1; i <= 100; i++ {
        waitGroup.Add(1)
        go perparePizza(&waitGroup, &rawMaterial, i)

    }
    for i := 0; i < 10; i++ {
        go backing()
    }
    waitGroup.Wait()
    fmt.Println("finished with remained material:", rawMaterial.material)
}

func perparePizza(wg *sync.WaitGroup, m *Material, num int) {
    defer wg.Done()
    //  fmt.Println("Preparing Pizza:", num)
    m.mutex.Lock()
    m.material--
    m.mutex.Unlock()
    //  time.Sleep(time.Second * 2)
    set(num)

    fmt.Printf("Pizza %d is ready \n", num)
}

func putInOven(num int) {
    //  fmt.Println("putInOven", num)
    time.Sleep(time.Second * 3)
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~