//Elevator.run
if (initQueue.noWaiting() && waitQueue.noWaiting()) {
    synchronized (waitQueue) { 
        try {
            waitQueue.wait(); //等待队列为空，需要先等输入线程接受新的输入
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
if (pattern.equals("Night")) {
    synchronized (waitQueue.getRequests()) { //Night模式下需要排序，给waitQueue类里的请求列表加锁
        waitQueue.getRequests()
            .sort(Comparator.comparingInt(PersonRequest::getFromFloor)); 
    }
}

//InputThread.run
synchronized (waitQueue) { //给waitQueue加锁保证线程安全
    if (request == null) {
        waitQueue.close();
        waitQueue.notifyAll(); //输入结束时唤醒等待队列，让Elevator类继续处理请求
        try {
            elevatorInput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return;
    } else {
        waitQueue.addRequest(request);
        waitQueue.notifyAll(); //有新的输入时唤醒等待队列，让Elevator类继续处理请求
    }
}

//Main.main 
try {
    inputThread.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
try {
    elevator.join();
} catch (InterruptedException e) {
    e.printStackTrace();
} //等两个线程均结束，主线程才结束

//Dispatcher.dispatch
if (waitQueue.isEnd() && waitQueue.noWaiting()) {
    for (Elevator elevator : elevators) {
        synchronized (elevator.getWaitQueue()) { //遍历时给每个电梯的等待队列类加上锁保证安全
            elevator.getWaitQueue().close();
            elevator.getWaitQueue().notifyAll(); 
            //输入线程结束且总等待队列为空将所有电梯的等待队列关闭，同时唤醒所有电梯
        }
    } 
    return;
} else {
    if (waitQueue.noWaiting()) {
        synchronized (waitQueue) {
            try {
                waitQueue.wait(); //总等待队列为空但输入线程并未结束时，先等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    } else {...}
}

//InputThread.run
synchronized (waitQueue) { //给总等待队列加锁，防止与调度器线程冲突
    if (request == null) {
        waitQueue.close(); //关闭总请求队列
        waitQueue.notifyAll(); //输入结束时唤醒调度器内的总等待队列
        try {
            elevatorInput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return;
    } else {
        if (request instanceof PersonRequest) {
            waitQueue.addRequest((PersonRequest) request);
        } else if (request instanceof ElevatorRequest) {
            Elevator elevator = new Elevator(new WaitQueue(), new InitQueue(),
                                             pattern, ((ElevatorRequest) request).getElevatorId());
            synchronized (elevators) { //给电梯数组加锁，保证线程安全
                elevators.add(elevator);
                elevator.start();
            }
        }
        waitQueue.notifyAll(); //在新的请求进入等待队列中或者加入了新电梯后唤醒所有的等待队列。
    }
}

//Elevator.run
if (d == 0) { //乘客到达目的地时
    ...
    TimableOutput.println(
        String.format("OUT-%d-%d-%s", request.getPersonId(), floor, id));
    synchronized (checkidset) {
        checkidset.remove(request.getPersonId()); //将这个id从换乘id集合中移除
        checkidset.notifyAll(); //唤醒换乘人集合，让调度器继续作业
    }
} else if ((type.equals("B") && canBOut(request))) { //到达中转站
  	...
    TimableOutput.println(String.format("OUT-%d-%d-%s",
                                        request.getPersonId(), floor, id));
    synchronized (allWaitQueue) {
        PersonRequest newrequest = new PersonRequest(floor,
                                                    request.getToFloor(), request.getPersonId());
        allWaitQueue.addRequest(newrequest); //总请求等待队列新增请求
        allWaitQueue.notifyAll(); //唤醒总请求等待对列，让调度器继续分配请求
    }
    synchronized (checkidset) { checkidset.notifyAll(); } //唤醒换乘人集合，让调度器继续作业
}

//Dispatcher.dispatch
if (waitQueue.isEnd() && waitQueue.noWaiting()) { //当输入线程已经终止时
    synchronized (checkidset) { //给换乘人集合加锁
        if (checkidset.size() > 0) { //当前还有换乘的乘客没有到达目的地
            try {
                checkidset.wait(); //等待乘客到达目的地或者新的换乘请求加入
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (waitQueue) { //处理现在的请求
                ArrayList<PersonRequest> requests = waitQueue.getRequests();
                for (int i = 0; i < requests.size(); i++) {
                    int mini = getMinElevatori(requests.get(i));
                    elevators.get(mini).addRequest(requests.get(i));
                    synchronized (elevators.get(mini).getWaitQueue()) {
                        elevators.get(mini).getWaitQueue().notifyAll();
                    }
                    requests.remove(i);
                    i--;
                }
            }
        }
        if (checkidset.size() > 0) { //如果还有没到达的换乘乘客，继续下一轮循环
            continue;
        }
    }
    for (Elevator elevator : elevators) { //所有换乘乘客均已到达，可以关闭各个线程的等待队列了
        synchronized (elevator.getWaitQueue()) {
            elevator.getWaitQueue().close(); 
            elevator.getWaitQueue().notifyAll();
        }
    }
    return;
} else {...} //输入线程未终止，正常分配请求

Exception in thread "Thread-1" java.util.ConcurrentModificationException
	at java.util.ArrayList.sort(ArrayList.java:1464)
	at Elevator.run(Elevator.java:68)

if (pattern.equals("Night")) {
        waitQueue.getRequests()
            .sort(Comparator.comparingInt(PersonRequest::getFromFloor));
}

while (floor != desFloor1) {
    try {
        sleep(400);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    floor += step;
    TimableOutput.println(
        String.format("ARRIVE-%d-%s", floor, id));
    desFloor1 = scheduler.getDesFloor(floor);
    //缺少这行:step=floor<desFloor1?:1:-1;
}

...
TimableOutput.println(String.format("OUT-%d-%d-%s",request.getPersonId(), floor, id));
synchronized (allWaitQueue) {
    PersonRequest newrequest = new PersonRequest(floor,request.getToFloor(), request.getPersonId());
    allWaitQueue.addRequest(newrequest);
    allWaitQueue.notifyAll();
}
...

if (lenInit == maxnum || (!initReqs.contains(mainRequest) && lenInit == maxnum - 1)) {
    return mainDesFloor;
}
mainDesFloor = maxnum == 6 ? getBFloor(floor, mainDesFloor) : mainDesFloor;