Eine einfache Go-Simulation – Probleme mit der Parallelität

php-Editor Xinyi bietet Ihnen ein einfaches, aber interessantes Go-Simulationsspiel namens „Concurrency Problem“. Dieses Spiel thematisiert die gleichzeitige Programmierung und ermöglicht es den Spielern, den Charme der gleichzeitigen Programmierung in einer virtuellen Welt zu erleben. Im Spiel müssen die Spieler Code schreiben, um die gleichzeitige Ausführung mehrerer Aufgaben zu bewältigen und ihre gleichzeitigen Programmierfähigkeiten zu testen. Die Spieloberfläche ist prägnant und klar, die Bedienung ist einfach, für Anfänger geeignet und bietet den Spielern außerdem mehrere Schwierigkeits- und Herausforderungsmodi zur Auswahl. Egal, ob Sie Anfänger oder erfahrener Entwickler sind, in diesem Simulationsspiel können Sie den Spaß am gleichzeitigen Programmieren genießen.

Frageninhalt

Ich bin ein Student aus Polen und habe dieses Semester einen parallelen Programmierkurs begonnen (Go, Ada und in Zukunft einige theoretische und CSP-Sprachen). Um ehrlich zu sein, sieht Golang interessant aus, aber ich bin etwas verwirrt. Unterm Strich würde ich mich selbst als unterdurchschnittlichen Programmierer bezeichnen. Grundsätzlich besteht meine Aufgabe darin, eine Simulation zu erstellen, die ich wie folgt beschreiben werde:

• Es gibt ein n*m-Raster

• Reisende können zufällig generiert werden, bis zu k Reisende, jeder Reisende hat eine eindeutige ID (1, 2, 3 usw., bis zu k)

• Wenn der Platz frei ist (ich bin sicher, dass der freie Platz 0 ist), kann sich der Reisende zu zufälligen Zeitpunkten im Raster nach oben, links, rechts oder unten bewegen

• Verfügt außerdem über eine Kamera, die manchmal den aktuellen Zustand des Netzes sowie aktuelle Bewegungen ausdruckt (noch nicht implementiert)

• Inoffiziell habe ich gehört, dass ich Kanäle verwenden sollte, was auch immer das bedeutet

Meine Idee ist es, eine Struktur mit der ID und den Koordinaten jedes Reisenden zu erstellen und seine ID an den Kanal zu senden, der die Bereitschaft zur Bewegung darstellt, und dann werde ich zufällig die Bewegungsrichtung auswählen.

Ich bin etwas verwirrt über Parallelität – nicht nur, ob und wo ich WGs und Mutexe verwenden soll, sondern auch, ob ich zum Beispiel func(){} gehe, ob die Schleife innerhalb oder außerhalb sein soll. Ich würde mich sehr über Tipps, Hilfe oder Korrekturen/Ideen zur Korrektur meines Codes freuen, da er derzeit, wie Sie vermutet haben, nicht richtig funktioniert (z. B. wenn die Kamera das Raster druckt, gibt es manchmal mehr als k Reisende, wo mehrere). Reisende teilen sich die gleiche Nummer und manchmal scheinen sie zu verschwinden). Ich hoffe, alle haben einen tollen Tag und ich würde mich wirklich über jede Hilfe freuen :)

package main;

import(
    "fmt"
    "os"
    "strconv"
    "math/rand"
    //"sync"
    "time"
)

type traveler struct{
    id int;
    x int;
    y int;
}

func main(){

    //command line
    n, err := strconv.Atoi(os.Args[1]);
    m, err := strconv.Atoi(os.Args[2]);
    k, err := strconv.Atoi(os.Args[3]);
    if err != nil{
        panic(err)
        return
    }

    //board
    var grid [][]int;
    grid = make([][]int, n)
    for i:=0; i<n; i++{
        grid[i] = make([]int, m)
    }

    //array of travelers, channel for moves and id
    travelers := make([]traveler, k)
    no_of_travelers := 0;
    move := make(chan int, k);
    id := 1;

    //var wg sync.WaitGroup

    go camera(grid);

    go func() {
        
        for i:=0; i<len(travelers); i++ {   
            if no_of_travelers<k{
                travelers[i] = spawnTraveler(&id,grid);
                no_of_travelers++;
            }
        }
    }()

    go func() {
        for{
            a:= rand.Intn(k);
            sendMoveTraveler(&travelers[a], move);
        }
    }()

    receiveMoveTraveler(travelers, move, grid);

}

func spawnTraveler(id *int, grid [][]int) traveler{
    x:=-1;
    y:=-1;
    for{
        x = rand.Intn(len(grid));
        y = rand.Intn(len(grid));
        if(grid[x][y]==0){
            break;
        }
    }
    t := traveler{id: *id, x: x, y:y};
    grid[x][y] = *id;
    *id++;
    return t;
}


func sendMoveTraveler(t *traveler, move chan int){
        move <- t.id
}

func receiveMoveTraveler(travelers []traveler, move chan int, grid [][]int){
    for{
        id := <- move
        for i:=0; i<len(travelers); i++{
            if travelers[i].id == id{
                direction := rand.Intn(4); //1-left 2-up 3-right 4-down
                switch direction {
                case 0:
                    if travelers[i].x>0 && grid[travelers[i].x-1][travelers[i].y] == 0{
                        grid[travelers[i].x-1][travelers[i].y] = grid[travelers[i].x][travelers[i].y];
                        grid[travelers[i].x][travelers[i].y] = 0;
                        travelers[i].x = travelers[i].x-1;
                        travelers[i].y = travelers[i].y;
                    }
                case 1:
                    if travelers[i].y>0 && grid[travelers[i].x][travelers[i].y-1] == 0{
                        grid[travelers[i].x][travelers[i].y-1] = grid[travelers[i].x][travelers[i].y];
                        grid[travelers[i].x][travelers[i].y] = 0;
                        travelers[i].x = travelers[i].x;
                        travelers[i].y = travelers[i].y-1;
                    }
                case 2:
                    if travelers[i].x<len(grid)-1 && grid[travelers[i].x+1][travelers[i].y] == 0{
                        grid[travelers[i].x+1][travelers[i].y] = grid[travelers[i].x][travelers[i].y];
                        grid[travelers[i].x][travelers[i].y] = 0;
                        travelers[i].x = travelers[i].x+1;
                        travelers[i].y = travelers[i].y;
                    }
                case 3:
                    if travelers[i].y<len(grid)-1 && grid[travelers[i].x][travelers[i].y+1] == 0{
                        grid[travelers[i].x][travelers[i].y+1] = grid[travelers[i].x][travelers[i].y];
                        grid[travelers[i].x][travelers[i].y] = 0;
                        travelers[i].x = travelers[i].x;
                        travelers[i].y = travelers[i].y+1;
                    }
                }
                //fmt.Println("Ściagnalem ruch", travelers[i].id);
            }
        }
    }
}

func camera(grid [][]int){
    for{
    for i:=0; i<len(grid); i++{
        for j:=0; j<len(grid); j++{
            if grid[i][j]!= 0{
                fmt.Printf("%02d ", grid[i][j]);
            } else{
                fmt.Printf("-- ");
            }
        }
        fmt.Println();
    }
    fmt.Println();
    time.Sleep(time.Second * 3);
}
}

Ich bin ein wenig überwältigt von all den Ideen – WGs, Mutexe, Atome usw.

Lösung

• Wenn Sie Arbeiten gleichzeitig verarbeiten möchten (z. B. das Aufnehmen eines Kameraschnappschusses und das Bewegen des Reisenden können gleichzeitig erfolgen), sind Goroutinen leichte Threads.
• Kanäle werden zum Übertragen von Daten zwischen Go-Routinen verwendet.
• Mutex wird verwendet, um Goroutinen das Hinzufügen von Sperren für gemeinsam genutzte Daten für den exklusiven Datenzugriff zu ermöglichen, um Race Conditions zu vermeiden.

Davon abgesehen:

• Kamera-Schnappschüsse in einer Goroutine auszuführen, während sich der Reisende in einer anderen Goroutine bewegt, sieht gut aus. Das Spawnen der Goroutine ist nicht notwendig, Sie müssen es nur einmal tun, damit Sie es in der Haupt-Goroutine ausführen können.
• In Ihrem Fall bringen Kanäle keinen Nutzen. Sie haben eine Goroutine, die eine Nachricht generiert und diese über einen Kanal an eine andere Goroutine sendet, die die Bewegung ausführt. Sie können dies alles nacheinander in einer einzigen Goroutine erledigen und unnötige Komplexität vermeiden. Kanäle sind für verschiedene Anwendungsfälle nützlich, hier sind sie jedoch überflüssig.
• Da Sie über zwei Goroutinen verfügen, die auf den gemeinsamen Speicher (das Raster) zugreifen, benötigen Sie einen Mutex, um Race Conditions zu vermeiden. Immer wenn einer dieser Befehle ausgeführt wird, muss er „gesperrt“ werden, seine Arbeit abschließen und dann „entsperrt“ werden. Eine andere Goroutine blockiert den Sperrschritt, bis die erste Goroutine, die die Sperre erworben hat, die Sperre aufhebt. Sie können es mithilfe von Lese-/Schreibsperren weiter optimieren (Lesesperren werden nur für die Kamera und Lese-/Schreibsperren für die mobile Coroutine benötigt)
• Wenn Sie mehr Zufälligkeit wünschen, können Sie für jeden Reisenden eine Goroutine erstellen.

Das obige ist der detaillierte Inhalt vonEine einfache Go-Simulation – Probleme mit der Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!