Блог

В настоящее время я создал такие классы, как автостоянка и этаж, для представления автостоянки. Я использовал ArrayList класса Floor для отображения нескольких уровней на автостоянке.

Я хочу иметь несколько входов и выходов на разных этажах, оборудованных лифтами для перехода с этажа на этаж.

Как мне подойти к этому? Я хочу иметь возможность добавлять и удалять несколько транспортных средств на автостоянку, когда транспортное средство въезжает и выезжает одновременно.

Как я могу использовать потоки и блокировки в этом случае?

============== Структура ============

 public class CarPark{

private ArrayList<Floor> floorList;
private ArrayList<Vehicle> vehicleList;

}
 

Реализованные методы:

• getFloorList() : ArrayList
• getVehicleList(): ArrayList

• getMostSuitableFloorForVehicle(транспортное средство): Этаж

• addVehicle (транспортное средство): void
• getFreeSlots(): double
• deleteVehicle(строка): транспортное средство
• getVehiclePercentages(): HashMap<строка, двойная>
• getOldestVehicle(): транспортное средство
• getLatestVehicle(): транспортное средство
• getVehicleById(строка): транспортное средство
• getVehicleByDayYear(строка, строка): ArrayList

     public class Floor implements Comparable<Floor>{
  
    private double maxCapacity;
    private double currentCapacity;
    private int currentNumberOfVehicles;
    private ArrayList<Vehicle> vehicleList;
    private ArrayList<VehicleTypes> preferredVehicleType;
    private ArrayList<VehicleTypes> possibleVehicleType;
   

  }

Реализованные методы:

• getCurrentNumberOfVehicles(): int
• getCurrentCapacity(): double
• getVehicleList(): ArrayList
• getPreferredVehicleType(): ArrayList
• getPossibleVehicleType(): ArrayList
• getAvailableNumberOfSlots(): double
• isParkingSlotsSufficient(транспортное средство): логическое значение
• addVehicle (транспортное средство): пустота
• getVehicleById(строка): транспортное средство
• deleteVehicleByInstance(Vehicle): транспортное средство
• deleteVehicleByPlateId(строка): транспортное средство
• toString(): Строка
• Сравнение (этаж): int

Остальные — это просто классы транспортных средств, которые будут добавлены на парковку.

Следующий mre использует два потока для имитации въезда и выезда автомобилей. Вы можете управлять скоростью, изменяя SLEEP время:

 import java.util.*;

public class CarPark {

    private static final int NUM_OF_FLOOORS = 4, SLEEP = 3000;
    private final List<Floor> floorList;

    public CarPark() {
        floorList = Collections.synchronizedList(new ArrayList<>());
        for(int i=0; i < NUM_OF_FLOOORS; i  ){
            floorList.add(new Floor(i));
        }
    }

    private Floor getRandomFloor() {
        Collections.shuffle(floorList);
        return floorList.get(0);
    }

    void simulateRandomTraffic(){
        simulateRandomEntries();
        simulateRandomExits();
    }

    void simulateRandomEntries(){
        new Thread(()->{
            while(true){
                getRandomFloor().addVehicle(new Vehicle());
                try {
                    Thread.sleep(SLEEP);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }).start();
    }

    void simulateRandomExits(){
        new Thread(()->{
            while(true){
                getRandomFloor().removeRandomVehicle();
                try {
                    Thread.sleep(SLEEP);
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        new CarPark().simulateRandomTraffic();
    }
}

class Floor{

    private final double maxCapacity = 100;
    private final List<Vehicle> vehicleList;
    private final int floorNumber;

    public Floor(int floorNumber) {
        this.floorNumber = floorNumber;
        vehicleList = Collections.synchronizedList(new ArrayList<>());
    }

    public int getCurrentNumberOfVehicles() {
        return vehicleList.size();
    }

    public boolean isFull(){
        return maxCapacity <= getCurrentNumberOfVehicles();
    }

    public boolean isEmpty(){
        return  getCurrentNumberOfVehicles() <= 0;
    }

    public int getFloorNumber() {
        return floorNumber;
    }

    private Vehicle getRandomVehicle() {
        Collections.shuffle(vehicleList);
        return vehicleList.get(0);
    }

    public boolean removeRandomVehicle(){
        if(isEmpty()) {
            System.err.println("Floor "  getFloorNumber() " is empty. Can't remove vehicle");
            return false;
        }
        return removeVehicle(getRandomVehicle());
    }

    public boolean addVehicle(Vehicle v){
        if(isFull()) {
            System.err.println("Floor "  getFloorNumber() " is full. Can't add vehicle");
            return false;
        }
        vehicleList.add(v);
        System.out.println("Floor "  getFloorNumber() " vehicle added ("  getCurrentNumberOfVehicles() "/" maxCapacity ")");
        return true;
    }

    public boolean removeVehicle(Vehicle v){
        if(isEmpty()) {
            System.err.println("Floor "  getFloorNumber() " is empty. Can't remove vehicle");
            return false;
        }
        vehicleList.remove(v);
        System.out.println("Floor "  getFloorNumber() " vehicle removed ("  getCurrentNumberOfVehicles() "/" maxCapacity ")");
        return true;
    }
}

class Vehicle{}
 

Следующее усовершенствование — автостоянка Queue .
Попросите третий поток вставить автомобили в Queue (или несколько запросов, по одному для каждого входа, все заполненные одним и тем же потоком).
simulateRandomEntries() Извлеките из очереди (или очередей) и переместите на случайный этаж.

Основой любой симуляции или игры является игровой цикл. Это цикл, который выполняется в течение определенного периода времени.

В Java вы можете использовать Runnable, добавленный в поток, для запуска цикла моделирования.

Вот пример Runnable .

 public class SimulationRunnable implements Runnable {
    
    /** Simulation run time, in minutes */
    private final int duration;
    
    private final Random random;
    
    private final SimulationView view;
    
    private final SimulationModel model;
    
    public SimulationRunnable(SimulationView view, SimulationModel model, 
            int duration) {
        this.view = view;
        this.model = model;
        this.duration = duration;
        this.random = new Random();
    }

    @Override
    public void run() {
        int iterations = duration * 60 * 5;
        
        for (int index = 0; index < iterations; index  ) {
            // Update simulation model
            
            // We will add cars for the first 10 hours (minutes)
            
            if (index < iterations - 600) {
                for (int jndex = 0; jndex < 5; jndex  ) {
                    if (random.nextInt(10) == 5) {
                        // Add car
                    }
                }
            }
            
            // We will remove cars for the last 10 hours (minutee)
            
            if (index > 600) {
                for (int jndex = 0; jndex < 5; jndex  ) {
                    if (random.nextInt(10) == 3) {
                        // Remove car
                    }
                }
            }
            
            // Report status every 300 iterations
            if (index % 300 == 0) {
                
            }
            
            // Pause simulation loop
            try {
                Thread.sleep(200L);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
}
 

Чтобы начать симуляцию, вы создаете с Thread помощью Runnable .

 new Thread(new SimulationRunnable(view, model, 12)).start();
 

Предположим, вы хотите смоделировать 12-часовой период, в течение которого автомобили въезжают на парковку и выезжают с нее. Одним из возможных вариантов моделирования может быть:

• Автомобили въезжают на парковку в течение первых двух часов.
• Автомобили въезжают и выезжают с парковки в течение следующих восьми часов.
• Автомобили покидают парковку в течение последних двух часов.

Давайте также предположим, что таймер моделирования работает как одна минута, представляющая один час. Таким образом, моделирование будет выполняться в течение 12 минут.

Давайте также предположим, что цикл моделирования выполняется пять раз в секунду. Это означает, что цикл моделирования будет выполняться один раз каждые 200 миллисекунд, в общей сложности 3600 исполнений.

Теперь все, что вам нужно сделать, это решить, сколько автомобилей въезжает на парковку в час и сколько автомобилей покидает парковку в час. Скорости должны быть довольно близки друг к другу.

Слишком много автомобилей, въезжающих на парковку в час, заполнят стоянку.

Слишком мало автомобилей, въезжающих на парковку в час, оставят парковку в основном пустой.

Игровой цикл обновит вашу имитационную модель. Время от времени, скажем, каждый игровой час (минуту), вы сообщаете о состоянии своей парковки.