怎么能把一些无聊的事连轴转地做完呢

Question

我有一个Go Project示例，试图模拟烘焙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都处于休眠状态-死锁！

Answer 1

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

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)
}