In der Go-Sprache werden gleichzeitige Operationen des Programms über Kanäle implementiert. Ein Kanal ist ein spezieller Typ zur Datenübertragung. Er ermöglicht den Datenaustausch und die Kommunikation zwischen Goroutinen. Wenn Sie jedoch in Ihrem Programm mit einem einzelnen Kanal arbeiten und diesen beim Einführen eines neuen Kanals nicht richtig handhaben, kann es zu einem Deadlock kommen. In diesem Artikel erklärt der PHP-Editor Xiaoxin ausführlich die Single-Channel-Arbeit und Deadlock-Probleme in Go-Programmen und wie man Deadlocks vermeidet.
Frageninhalt
Ich bin neu bei Go-Kanälen und versuche, Go-Kanäle zu erlernen, indem ich einen Scheinkern baue und Interaktionen über Kanäle handhabe. Das Ziel dieses Beispielprogramms besteht darin, dass mehrere Prozesse (2) gleichzeitig Speicherzuweisungsanfragen über einen Kanal an den Kernel senden und andere Prozesse Speicherfreigabeanfragen über einzelne, aber unterschiedliche Kanäle an den Kernel senden .
+-------------+
+------------------+ | |
-> Alloc. Mem. Ch. |<--\ | |
+-----------------+ ---/ +------------------+ >-->| Kernel |
| Process A |<-- +------------------+ -/ | |
+-----------------+ \--> | Realse Mem. Ch. |< | |
+------------------+ +-------------+Nach dem Login kopieren
Wenn ich nur Zuteilungsanfragen habe, funktioniert das Programm, sobald ich Freigabeanfragen eingebe, gerät das Programm in einen Deadlock.
Beachten Sie, dass der Prozess beim Senden einer Zuteilungsanfrage auch eine Antwortwarteschlange erstellt. Dies wird jedoch im obigen Bild nicht angezeigt, da es nicht Teil des Problems ist.
Der vollständige Ablauf ist wie folgt:
package main
import (
"fmt"
// "log"
"time"
)
const (
_ float64 = iota
LowPrio
MedPrio
HghPrio
)
// Kernel type to communicate between processes and memory resources
type Kernel struct {
reqMemCh chan chan int
rlsMemCh chan int
}
func (k *Kernel) Init() {
k.reqMemCh = make(chan chan int, 2)
k.rlsMemCh = make(chan int, 2)
go k.AllocMem()
go k.RlsMem()
}
// Fetch memory on process request
func (k *Kernel) GetReqMemCh() chan chan int {
return k.reqMemCh
}
func (k *Kernel) GetRlsMemCh() chan int {
return k.rlsMemCh
}
func (k *Kernel) AllocMem() {
// loop over the items (process reply channels) received over
// the request channel
for pCh := range k.GetReqMemCh() {
// for now think 0 is the available index
// send this as a reply to the exclusive process reply channel
pCh <- 0
close(pCh)
}
}
// Release memory
func (k *Kernel) RlsMem() {
// we do not have to anything here
}
// Process type which requests memory
type Proc struct {
ind int
prio float64
exeT time.Time
count int
memInd int
rqMemCh chan chan int
rlMemCh chan int
}
func (p *Proc) Init(
ind int,
prio float64,
rqMemCh chan chan int,
rlMemCh chan int,
) {
p.ind = ind
p.prio = prio
p.memInd = -1
p.rqMemCh = rqMemCh
p.rlMemCh = rlMemCh
}
func (p *Proc) GetReqMemCh() chan chan int {
return p.rqMemCh
}
func (p *Proc) GetRlsMemCh() chan int {
return p.rlMemCh
}
func (p *Proc) ReqMem() {
// create the reply channel exclusive to the process
// this channel will return the allocated memeory id/address
rpCh := make(chan int)
// send the reply channel through the request channel
// to get back the allocation memory id
p.GetReqMemCh() <- rpCh
// Below line is blocking ...
for mi := range rpCh {
p.memInd = mi
}
}
func (p Proc) RlsMem() {
p.GetRlsMemCh() <- 0
}
func (p Proc) String() string {
return fmt.Sprintf(
"Proc(%d): Memory(%d), Count(%d)",
p.ind+1, p.memInd+1, p.count,
)
}
func main() {
k := &Kernel{}
k.Init()
p := &Proc{}
for i := 0; i < 3; i++ {
p.Init(i, LowPrio, k.GetReqMemCh(), k.GetRlsMemCh())
p.ReqMem()
p.RlsMem()
}
time.Sleep(time.Second)
}Nach dem Login kopieren
Ausnahmen sind wie folgt:
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.Proc.RlsMem(...)
main.go:100
main.main()
main.go:119 +0xc5
goroutine 6 [chan receive]:
main.(*Kernel).AllocMem(0x0?)
main.go:41 +0x5e
created by main.(*Kernel).Init in goroutine 1
main.go:25 +0xc5
exit status 2Nach dem Login kopieren
Jede Hilfe wäre sehr dankbar.
Cheers,
DD.
Workaround
Als britischer Kommentator haben Sie einen Pufferkanal, der seine Kapazität erreicht hat, aber nichts zu lesen hat.
Entsprechend der Sprachtour (1 2) Blöcke senden und empfangen, bis die andere Partei bereit ist. Obwohl gepufferte Kanäle hier eine gewisse Toleranz bieten, ist das Verhalten dasselbe, sobald der Puffer voll ist.
Dieses Problem kann gelöst werden, indem ein Benutzer von k.rlsMemCh hinzugefügt wird. Wenn Sie hierfür nichts geplant haben, löschen Sie den Kanal oder nutzen Sie die Logik, um ihn vorübergehend zu entleeren.
<code>func (k *Kernel) Init() {
k.reqMemCh = make(chan chan int, 2)
k.rlsMemCh = make(chan int, 2)
go k.AllocMem()
go k.RlsMem()
}
func (k *Kernel) AllocMem() {
for pCh := range k.GetReqMemCh() {
pCh <- 0
close(pCh)
}
}
func (k *Kernel) RlsMem() {
// TODO: Add a for-select or for-range over k.rlsMemCh here
}
</code>Nach dem Login kopieren
Entwässerung könnte so aussehen:
func (k *Kernel) RlsMem() {
for {
<-k.GetRlsMemCh()
}
}Nach dem Login kopieren
Das obige ist der detaillierte Inhalt vonDas Go-Programm arbeitet mit einem einzelnen Kanal und gerät in einen Deadlock, wenn ein neuer Kanal eingeführt wird. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
