多线程Java如何让线程等待一段时间

停车问题

有n个停车场。在一个停车场上，一次只能有一辆车。如果所有停车场都被占用，那么汽车将等待一段时间，如果仍然没有免费停车场，那么它将离开

它需要使用线程（通过will同步）来解决

这是我的密码：

停车

class Parking implements Runnable {
private Thread thread;
private String threadName;
static int parkingLots;

static {
    parkingLots = 5;
}

Parking(String threadName) {
    this.threadName = threadName;
}

public void run() {
    if (parkingLots > 0) {
        long restTime = (long) (Math.random() * 2000);
        try {
            parkingLots--;
            System.out.println("Car " + threadName + " stands in the parking lot");
            Thread.sleep(restTime);
        } catch (InterruptedException e) {
        }
        parkingLots++;
        System.out.println("Car " + threadName + " has left parking, it stood there" + ((double)restTime / (double)1000) + " s");
    } else
        System.out.println("Car " + threadName + " has left parking");
}

public void start() {
    if (thread == null) {
        thread = new Thread(this, threadName);
        thread.start();
    }
}
}

Main

public class Main {
    public static void main(String[] args) {
        ArrayList<Parking> parking = new ArrayList<Parking>();

        for (int i = 0; i < 15; i++) {
            parking.add(new Parking(String.valueOf(i + 1)));
        }
        for (Parking i: parking) {
            i.start();
        }
    }
}

但我得到的（当有2个停车场和4辆车时）：所有第一辆车（1和2）都停在停车场，其他车（3和4）都离开了，因为没有免费停车场。即使有15辆车，他们还是进不去

---

那么，我怎样才能让汽车在离开前等待一段时间呢？如果有免费停车场，他们会去那里，否则他们会离开停车场。

修改了你的代码，看看这是否有效

public class Parking implements Runnable {
    private Thread thread;
    private String threadName;
    static int parkingLots;

    static {
        parkingLots = 5;
    }

    Parking(String threadName) {
        this.threadName = threadName;
    }

    public void run() {
        long restTime = (long) (Math.random() * 2000);
        if (parkingLots > 0) {
            checkparking();
        } else {
            try {
                System.out.println("Car " + threadName + " is waiting");
                Thread.sleep(restTime);
                System.out.println("Car " + threadName + " is checking for free parkinglot");
                checkparking();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    public void checkparking() {
        if (parkingLots > 0) {
        long restTime = (long) (Math.random() * 2000);
        try {
            parkingLots--;
            System.out.println("Car " + threadName + " stands in the parking lot");
            Thread.sleep(restTime);
        } catch (InterruptedException e) {
        }
        parkingLots++;
        System.out.println(
                "Car " + threadName + " has left parking, it stood there" + ((double) restTime / (double) 1000) + " s");

    } else {
        System.out.println(
                "Car " + threadName + " has left since there is no parking space");
    }
    }

    public void start() {
        if (thread == null) {
            thread = new Thread(this, threadName);
            thread.start();
        }
    }

}

公共班机{

     public static void main(String[] args) {
            ArrayList<Parking> parking = new ArrayList<Parking>();

            for (int i = 0; i < 15; i++) {
                parking.add(new Parking(String.valueOf(i + 1)));
            }
            for (Parking i: parking) {
                i.start();
            }
        }
}

---

您没有使用和同步，您的类不应该实现Runnable，并且您使用的语义不正确

例如，启动后汽车不能停车/离开，多线程是指多个线程同时访问某个对象，而不会导致不一致的状态，在您的情况下，您基本上只是创建线程并执行某些操作

您的结构应该是这样的：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Parking  {

    private final Lock monitor = new ReentrantLock();
    private final Condition lotAvailable = monitor.newCondition();

    private List<Car> parkedCars = new ArrayList<>();

    private final int maxCapacity;
    private int occupied;

    public Parking(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

    private boolean tryPark(Car car, int maxWaitingMillis) throws InterruptedException{
        try {
            monitor.lock();
            if(occupied >= maxCapacity){
                long nanos = lotAvailable.awaitNanos(maxWaitingMillis);
                while (occupied >= maxCapacity) {
                    if (nanos <= 0L)
                        return false;
                    nanos = lotAvailable.awaitNanos(nanos);
                }
                ++occupied;
                parkedCars.add(car);
                return true;
            }
            ++occupied;
            parkedCars.add(car);
            return true;
        }catch (InterruptedException ie){
            System.out.println(ie.getMessage());
            throw ie;
        }finally {
            monitor.unlock();
        }

    }

    private void leave(Car car){
        try {
            monitor.lock();
            if(parkedCars.remove(car)) {
                --occupied;
                lotAvailable.signal();
            }
        }catch (Exception e){
            System.out.println(e.getMessage());
        }finally {
            monitor.unlock();
        }
    }


}

import java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.locks.Condition；
导入java.util.concurrent.locks.Lock；
导入java.util.concurrent.locks.ReentrantLock；
公共停车场{
私有最终锁定监视器=新的ReentrantLock（）；
私有最终条件lotAvailable=monitor.newCondition（）；
私人列表parkedCars=new ArrayList（）；
私人最终int最大容量；
私人住宅；
公共停车场（国际最大容量）{
this.maxCapacity=maxCapacity；
}
私有布尔tryPark（Car-Car，int-maxWaitingMillis）抛出中断异常{
试一试{
monitor.lock（）；
如果（占用>=最大容量）{
long nanos=LOT可用。等待nanos（最大等待毫秒）；
同时（占用>=最大容量）{
如果（Nano如果你没有使用同步，你应该使用一个锁对象和一些条件变量以正确的方式实现它，这段代码需要以正确的方式进行一些严重的重构。不要将
线程
放在
可运行的
中。它应该是另一种方式。将主类视为协调器；it将管理
ParkingLot
和
Car
类型的线程和实例化细节，每个类型都有一个
Runnable#run
方法。
Car 2 stands in the parking lot
Car 1 stands in the parking lot
Car 7 is waiting
Car 5 stands in the parking lot
Car 3 stands in the parking lot
Car 6 is waiting
Car 4 stands in the parking lot
Car 9 is waiting
Car 8 is waiting
Car 10 is waiting
Car 11 is waiting
Car 12 is waiting
Car 13 is waiting
Car 14 is waiting
Car 15 is waiting
Car 4 has left parking, it stood there0.049 s
Car 14 is checking for free parkinglot
Car 14 stands in the parking lot
Car 5 has left parking, it stood there0.366 s
Car 2 has left parking, it stood there0.461 s
Car 12 is checking for free parkinglot
Car 12 stands in the parking lot
Car 15 is checking for free parkinglot
Car 15 stands in the parking lot
Car 1 has left parking, it stood there0.882 s
Car 9 is checking for free parkinglot
Car 9 stands in the parking lot
Car 10 is checking for free parkinglot
Car 10 has left since there is no parking space
Car 3 has left parking, it stood there1.014 s
Car 13 is checking for free parkinglot
Car 13 stands in the parking lot
Car 15 has left parking, it stood there0.937 s
Car 6 is checking for free parkinglot
Car 6 stands in the parking lot
Car 11 is checking for free parkinglot
Car 11 has left since there is no parking space
Car 13 has left parking, it stood there0.344 s
Car 7 is checking for free parkinglot
Car 7 stands in the parking lot
Car 8 is checking for free parkinglot
Car 8 has left since there is no parking space
Car 7 has left parking, it stood there0.054 s
Car 14 has left parking, it stood there1.731 s
Car 9 has left parking, it stood there1.359 s
Car 12 has left parking, it stood there1.877 s
Car 6 has left parking, it stood there1.787 s

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Parking  {

    private final Lock monitor = new ReentrantLock();
    private final Condition lotAvailable = monitor.newCondition();

    private List<Car> parkedCars = new ArrayList<>();

    private final int maxCapacity;
    private int occupied;

    public Parking(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

    private boolean tryPark(Car car, int maxWaitingMillis) throws InterruptedException{
        try {
            monitor.lock();
            if(occupied >= maxCapacity){
                long nanos = lotAvailable.awaitNanos(maxWaitingMillis);
                while (occupied >= maxCapacity) {
                    if (nanos <= 0L)
                        return false;
                    nanos = lotAvailable.awaitNanos(nanos);
                }
                ++occupied;
                parkedCars.add(car);
                return true;
            }
            ++occupied;
            parkedCars.add(car);
            return true;
        }catch (InterruptedException ie){
            System.out.println(ie.getMessage());
            throw ie;
        }finally {
            monitor.unlock();
        }

    }

    private void leave(Car car){
        try {
            monitor.lock();
            if(parkedCars.remove(car)) {
                --occupied;
                lotAvailable.signal();
            }
        }catch (Exception e){
            System.out.println(e.getMessage());
        }finally {
            monitor.unlock();
        }
    }


}