In this article, we’ll go through a low-level design (LLD) implementation of a parking lot system in Go. We'll explore different aspects of the system and see how each component interacts with the rest. This implementation focuses on clarity and real-world usefulness, so you can extend it easily if you want to add features like more vehicle types, multiple payment options, or spot reservations.
The system handles tasks like managing parking floors and spots, parking and unparking vehicles, and processing payments. We’ll also ensure it’s thread-safe for concurrent access, so if we need to expand it into a larger system, it won’t break down under pressure.
Our design includes six main components:
Our ParkingLot uses the Singleton pattern. This means there’s only one instance of the parking lot, which is created once and reused across the application. Here’s the code to get that working:
var (
parkingLotInstance *ParkingLot
once sync.Once
)
type ParkingLot struct {
Name string
floors []*ParkingFloor
}
func GetParkingLotInstance() *ParkingLot {
once.Do(func() {
parkingLotInstance = &ParkingLot{}
})
return parkingLotInstance
}
Using sync.Once, we ensure that only one instance is created, even when accessed by multiple goroutines.
The parking lot has multiple floors, each with designated parking spots for different vehicle types (e.g., cars, vans, trucks, and motorcycles). To add a floor to the parking lot, we use the AddFloor method:
func (p *ParkingLot) AddFloor(floorID int) {
p.floors = append(p.floors, NewParkingFloor(floorID))
}
Each floor is created using the NewParkingFloor function, which organizes spots by vehicle type.
Each ParkingSpot is associated with a specific vehicle type (like a car or motorcycle). This allows the system to manage and restrict which vehicles can park in each spot. Here’s the ParkingSpot structure and the ParkVehicle method:
type ParkingSpot struct {
SpotID int
VehicleType vehicles.VehicleType
CurrentVehicle *vehicles.VehicleInterface
lock sync.Mutex
}
func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
p.lock.Lock()
defer p.lock.Unlock()
if vehicle.GetVehicleType() != p.VehicleType {
return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
}
if p.CurrentVehicle != nil {
return fmt.Errorf("parking spot already occupied")
}
p.CurrentVehicle = &vehicle
return nil
}
We use a Mutex lock to make sure only one vehicle can park in a spot at a time.
Every vehicle gets a ticket with the entry time, exit time, parking spot, and total charge. This ticket will be updated when the vehicle exits, and charges will be calculated based on the time spent parked.
var (
parkingLotInstance *ParkingLot
once sync.Once
)
type ParkingLot struct {
Name string
floors []*ParkingFloor
}
func GetParkingLotInstance() *ParkingLot {
once.Do(func() {
parkingLotInstance = &ParkingLot{}
})
return parkingLotInstance
}
The CalculateTotalCharge method calculates parking fees based on the vehicle type and duration.
The PaymentSystem class processes the payment, updating the payment status based on whether the required amount is paid:
func (p *ParkingLot) AddFloor(floorID int) {
p.floors = append(p.floors, NewParkingFloor(floorID))
}
The ProcessPayment function checks the amount and updates the payment status to Completed or Failed.
Our system supports different types of vehicles (cars, vans, trucks, and motorcycles). Each type has a different hourly charge. This is achieved by setting up a VehicleType and VehicleInterface in a separate vehicles package:
type ParkingSpot struct {
SpotID int
VehicleType vehicles.VehicleType
CurrentVehicle *vehicles.VehicleInterface
lock sync.Mutex
}
func (p *ParkingSpot) ParkVehicle(vehicle vehicles.VehicleInterface) error {
p.lock.Lock()
defer p.lock.Unlock()
if vehicle.GetVehicleType() != p.VehicleType {
return fmt.Errorf("vehicle type mismatch: expected %s, got %s", p.VehicleType, vehicle.GetVehicleType())
}
if p.CurrentVehicle != nil {
return fmt.Errorf("parking spot already occupied")
}
p.CurrentVehicle = &vehicle
return nil
}
We can create new vehicles by calling NewCar, NewVan, NewTruck, etc., each of which implements VehicleInterface.
Let’s see how the pieces fit together in a flow:
This parking lot system is a simplified starting point for building more complex systems. We covered the basics of floor and spot management, vehicle parking and unparking, and a basic payment process.
For full code implementation, check the following repository:
thesaltree
/
low-level-design-golang
Welcome to the Low-Level System Design in Go repository! This repository contains various low-level system design problems and their solutions implemented in Go. The primary aim is to demonstrate the design and architecture of systems through practical examples.
Low-level system design involves understanding the core concepts of system architecture and designing scalable, maintainable, and efficient systems. This repository will try to cover solutions of various problems and scenarios using Go.
The first project in this repository is a Parking Lot System. This system simulates a parking lot where vehicles can be parked and unparked. It demonstrates:
The above is the detailed content of System Design: Building a Parking Lot System in Go. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
