使用多线程在 Java 中模拟停车场中的多个入口和出口

Question

我目前创建了 CarPark 和 Floor 等类来表示停车场。我使用了 Floor 类的 ArrayList 来显示停车场的多个楼层。

我想在不同楼层有多个出入口，配备电梯从一层到另一层。

我应该如何处理这个问题？我希望能够在车辆同时进入和离开时向停车场添加和删除多辆车辆。

在这种情况下如何使用线程和锁？

==============结构============

public class CarPark{

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

}

实现的方法：

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

• getMostSuitableFloorForVehicle(Vehicle): 楼层

• addVehicle(Vehicle): 无效

• getFreeSlots(): 双倍

• deleteVehicle(String): 车辆

• getVehiclePercentages(): HashMap

• getOldestVehicle(): 车辆

• getLatestVehicle(): 车辆

• getVehicleById(String): 车辆

• getVehicleByDayYear(String, String): 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(): 双倍
• getVehicleList(): ArrayList
• getPreferredVehicleType(): ArrayList
• getPossibleVehicleType(): ArrayList
• getAvailableNumberOfSlots(): 双倍
• isParkingSlotsSufficient(Vehicle): 布尔值
• addVehicle(Vehicle 车辆): void
• getVehicleById(String): 车辆
• deleteVehicleByInstance(Vehicle): 车辆
• deleteVehicleByPlateId(String): 车辆
• toString(): 字符串
• compareTo(Floor): int

其余只是将添加到停车场的车辆类别。

Answer 1

下面的 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() 从队列（或多个队列）中拉出并推送到随机楼层。

Answer 2

任何模拟或游戏的基础都是game loop。这是一个循环运行一段时间。

在 Java 中，您可以使用添加到 Thread 的 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();
            }
        }
    }
    
}

要开始模拟，请使用Runnable 创建一个Thread。

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

假设您要模拟汽车进出停车场的 12 小时时段。一种可能的模拟可能是：

• 前两个小时有汽车进入停车场。
• 汽车在接下来的八小时内进出停车场。
• 汽车在过去两个小时内离开停车场。

我们还假设模拟计时器以一分钟代表一小时运行。所以模拟将运行 12 分钟。

我们还假设模拟循环每秒运行五次。这意味着模拟循环将每 200 毫秒执行一次，总共执行 3,600 次。

现在您所要做的就是确定每小时有多少汽车进入停车场，以及每小时有多少汽车离开停车场。价格应该非常接近。

每小时进入停车场的汽车太多会填满停车场。

每小时进入停车场的车辆太少，停车场大部分都是空的。

游戏循环将更新您的模拟模型。每隔一段时间，比如说你在每个游戏小时（分钟）报告你的停车场的状态。