Technischer Bericht: Entwicklung eines gleichzeitigen Parksimulators in Go

Einführung

Dieses Projekt besteht aus einem gleichzeitigen Parksimulator, der in Go entwickelt wurde und die grafische Bibliothek Fyne für die Benutzeroberfläche verwendet. Sein Ziel besteht darin, das Verhalten eines Parkplatzes in Echtzeit zu modellieren, die Ein- und Ausfahrt von Fahrzeugen gleichzeitig zu verwalten und den aktualisierten Status der Parkplätze visuell anzuzeigen.
Das Projekt kombiniert die Konzepte der Parallelität, des Observer-Entwurfsmusters und des dynamischen Renderings in einer grafischen Oberfläche. Dieser Bericht beschreibt detailliert die Verwendung dieser Tools, die aufgetretenen Herausforderungen (insbesondere beim Observer- und Fyne-Muster) und wie sie gelöst wurden, mit dem Ziel, eine technische Referenz für andere Entwickler bereitzustellen.

1. Fyne-Initialisierung

Fyne ist eine moderne Bibliothek zur Entwicklung grafischer Schnittstellen mit Go. Die Grundinitialisierung folgt diesen Schritten:

1. Erstellen Sie eine neue Anwendung mit app.New().
2. Konfigurieren Sie das Hauptfenster mit app.NewWindow().
3. Entwerfen Sie Inhalte mit Fyne-Containern und Widgets.
4. Rufen Sie ShowAndRun() auf, um die Anwendung auszuführen.

Im Simulator wurde ein Hauptfenster erstellt, das die Parkplatzansicht integriert und eine Verbindung zum gleichzeitigen Logikmodell herstellt:

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Dieser grundlegende Ablauf erleichtert die Trennung zwischen der Geschäftslogik und der grafischen Oberfläche.

2. Verwendung des Beobachtermusters

Warum das Observer-Muster verwenden

Das Observer-Muster wurde verwendet, um die Modell- und Ansichtsebenen synchron zu halten. Wenn ein Fahrzeug den Parkplatz betritt oder verlässt, benachrichtigt das Modell die Ansicht, die die entsprechenden grafischen Elemente aktualisiert. Dieses Muster ist ideal für Systeme, bei denen mehrere Komponenten auf dasselbe Ereignis reagieren müssen.

Bei der Verwendung des Observer-Musters in Go sind Probleme aufgetreten

Die Implementierung des Observer-Musters in Go kann eine Herausforderung sein, insbesondere für diejenigen, die mit der Implementierung in objektorientierten Sprachen wie Java oder C# vertraut sind. Ein häufiges Problem bei der Verwendung dieses Musters in Go ist der Umgang mit Parallelität und Deadlocks bei der Benachrichtigung von Beobachtern.

Anfangs führte die Iteration über im Modell registrierte Beobachter (Parken) zur Meldung von Ereignissen zu Rennbedingungen und Abstürzen. Dies geschah, weil die Methode zur Registrierung neuer Beobachter nicht ordnungsgemäß geschützt war, was zu gleichzeitigen Zugriffen auf die Beobachterliste führte.

Wie es gelöst wurde
Um dieses Problem zu lösen, wurde ein Mutex (sync.Mutex) verwendet, um den gleichzeitigen Zugriff auf die Beobachterliste zu schützen. Darüber hinaus wurden sichere Methoden zur Registrierung von Beobachtern und zur Meldung von Ereignissen implementiert:

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Komplette Umsetzung im Projekt
Das Parkplatzmodell fungiert als beobachtbares Subjekt, während die MainScene und andere Komponenten, wie z. B. die Diagrammansicht, Beobachter sind:
1. Definition der Beobachterschnittstelle:

func (e *Estacionamiento) RegistrarObservador(o Observer) {
    e.mu.Lock()
    defer e.mu.Unlock()
    e.observadores = append(e.observadores, o)
}

func (e *Estacionamiento) NotificarVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int) {
    e.mu.Lock()
    defer e.mu.Unlock()
    for _, o := range e.observadores {
        o.OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad)
    }
}

func (e *Estacionamiento) NotificarVehiculoSale(id, cajon, espaciosDisponibles, capacidad int) {
    e.mu.Lock()
    defer e.mu.Unlock()
    for _, o := range e.observadores {
        o.OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad)
    }
}

1. Ereignisbenachrichtigung vom Modell:

package models

type Observer interface {
    OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int)
    OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad int)
}

1. Antwort des Beobachters:

func (e *Estacionamiento) VehiculoEntra(id int) {
    // Lógica para manejar la entrada del vehículo
    espaciosDisponibles := e.capacidad - e.ocupados
    e.NotificarVehiculoEntra(id, cajon, espaciosDisponibles, e.capacidad)
}

func (e *Estacionamiento) VehiculoSale(id int) {
    // Lógica para manejar la salida del vehículo
    espaciosDisponibles := e.capacidad - e.ocupados
    e.NotificarVehiculoSale(id, cajon, espaciosDisponibles, e.capacidad)
}

Diese Lösung stellt sicher, dass Aktualisierungen konsistent sind und dass Rennbedingungen die Systemleistung nicht beeinträchtigen.

3. Technisches Problem: Rendering und Positionsberechnung

Kontext

Die größte technische Herausforderung bestand darin, die Positionen der Schubladen in der grafischen Oberfläche zu berechnen und ihre Farbe in Echtzeit zu aktualisieren. Die Schubladen sollten:

1. Seien Sie in zwei Reihen mit gleichmäßigem Abstand angeordnet.
2. Ändern Sie die Farbe dynamisch (rot für besetzt, schwarz für verfügbar).

Identifizierte Probleme

1. Dynamische Positionsberechnung: Die Parkplätze mussten in zwei Reihen mit gleichmäßigem Abstand zueinander positioniert werden. Die Berechnung und Aktualisierung dieser Positionen war jedoch komplex, da sie von genauen Koordinaten innerhalb eines Containers ohne Layout (container.NewWithoutLayout()) abhing.
2. Visuelle Synchronisierung: Bei der Verarbeitung mehrerer gleichzeitiger Threads traten visuelle Inkonsistenzen auf, wenn versucht wurde, die Schubladenfarben in Echtzeit zu aktualisieren. Manchmal wurden Änderungen nicht berücksichtigt oder führten zu grafischen Fehlern.

Positionsberechnung
Absolute Koordinaten wurden verwendet, um die Anfangsposition und den Anfangsabstand zu definieren:

func (s *MainScene) OnVehiculoEntra(id, cajon, espaciosDisponibles, capacidad int) {
    s.View.UpdateState(espaciosDisponibles, capacidad, id, cajon, "entra")
}

func (s *MainScene) OnVehiculoSale(id, cajon, espaciosDisponibles, capacidad int) {
    s.View.UpdateState(espaciosDisponibles, capacidad, id, cajon, "sale")
}

Dynamisches Rendering
Es wurden Funktionen implementiert, um die Schubladen entsprechend ihrem Status zu bemalen:

xStart, yTop, yBottom := float32(185), float32(120), float32(200)
spotSpacing := float32(55)

// Fila superior
for i := 0; i < 10; i++ {
    parkingSpots = append(parkingSpots, fyne.Position{X: xStart + float32(i)*spotSpacing, Y: yTop})
}

// Fila inferior
for i := 0; i < 10; i++ {
    parkingSpots = append(parkingSpots, fyne.Position{X: xStart + float32(i)*spotSpacing, Y: yBottom})
}

Visuelle Synchronisation
Um sicherzustellen, dass visuelle Änderungen mit dem Systemstatus übereinstimmen, wurden der Hauptetikettentext und der Schubladenstatus innerhalb einer zentralen Funktion aktualisiert:

func main() {
    myApp := app.New()
    mainWindow := myApp.NewWindow("Simulador de Parking")

    estacionamiento := models.NewEstacionamiento(20)
    parkingView := views.NewParkingView()

    mainScene := scenes.NewMainScene(estacionamiento, parkingView)
    mainWindow.SetContent(parkingView.Container)

    mainWindow.ShowAndRun()
}

Dadurch ist jederzeit eine genaue und aktuelle grafische Darstellung gewährleistet.

Fazit

Dieses Projekt hat nicht nur sein Ziel erreicht, gleichzeitiges Parken zu simulieren, sondern steht auch vor praktischen Entwicklungsproblemen, wie der Verwendung des Observer-Musters und der Erstellung grafischer Schnittstellen mit Fyne. Die aufgetretenen Probleme und die implementierten Lösungen sollen als Leitfaden für andere Entwickler dienen, die mit Go beginnen oder vor ähnlichen Herausforderungen stehen.
Insbesondere die Implementierung des Observer-Musters in Go zeigt, wie man Parallelität sicher und effizient handhabt. Dieser Bericht soll durch die Dokumentation dieser Probleme und Lösungen einen Beitrag zur Gemeinschaft von Programmierern leisten, die daran interessiert sind, diese Tools zu erlernen und anzuwenden, und ihren Lern- und Entwicklungsprozess zu erleichtern.
Wenn Sie Fragen zur Implementierung und Lösung haben, können Sie mein Github-Repository konsultieren: simulador-parking.git

Das obige ist der detaillierte Inhalt vonTechnischer Bericht: Entwicklung eines gleichzeitigen Parksimulators in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!