在多个队列之间创建交替顺序依赖关系

Question

在具有多个队列的环境中，我想确定入队/出队顺序并相应地找到等待时间。

主要：

LinkedList<Event> schedule = initializeSchedule(state);
LinkedList<Event> schedule2 = initializeSchedule(state2);
LinkedList<Event> schedule3 = initializeSchedule(state3);

while (time < state.simulationTime) {
Event event = schedule.removeLast();
if (time == 0.0) {
event.serviceStart = event.interarrival;
event.serviceEnd = event.serviceStart + event.service;
event.tw = event.serviceStart - event.arrival;
event.tq = event.serviceEnd - event.arrival;
}
event.function(schedule, state, time);
count++;
time = event.arrival;
wait += event.tw;
turnaround += event.tq;
}

while (time2 < state2.simulationTime) {
Event event2 = schedule2.removeLast();
if (time2 == 0.0) {
event2.serviceStart = event2.interarrival;
event2.serviceEnd = event2.serviceStart + event2.service;
event2.tw = event2.serviceStart - event2.arrival;
event2.tq = event2.serviceEnd - event2.arrival;
}
event2.function(schedule2, state2, time2);
count2++;
time2 = event2.arrival;
wait2 += event2.tw;
turnaround2 += event2.tq;
}

这是LinkedList initializeSchedule（状态）：

public static LinkedList<Event> initializeSchedule(State state) {
    LinkedList<Event> schedule = new LinkedList<Event>();
    double time = 0.0;
    for (int i = 0; i < 10000; i++) {
        Event event = new Event();
        event.id = i;
        event.interarrival = exponential(state.lambda);
        event.service = exponential(state.ts);
        time += event.interarrival;
        event.arrival = time;
        schedule.push(event);

    }
    return schedule;
}

这是事件：

public static class Event {
    public int id;
    public double interarrival;
    public double arrival;
    public double service;
    public double serviceStart;
    public double serviceEnd;
    public double tw;
    public double tq;

    public void function(LinkedList<Event> schedule, State state, double time) {
        Event next = schedule.removeLast();
        if (this.serviceEnd < next.arrival) {
            next.serviceStart = next.arrival;
        }
        if (this.serviceEnd >= next.arrival) {
            next.serviceStart = this.serviceEnd;
        }
        next.serviceEnd = next.serviceStart + next.service;
        next.tw = next.serviceStart - next.arrival;
        next.tq = next.serviceEnd - next.arrival;

        schedule.addLast(next);
    }
}

指数分布：

public static double exponential(double lambda) {
    Random R = new Random();
    return -(Math.log(1 - R.nextDouble()) / lambda);
}

这是模拟的结果

Results of Queue 1
Number of Events Processed: 421
Average Wait Time in Queue 1:   1.1149181700382145
Average Time in System 1:   1.3104415204881015

Results of Queue 2
Number of Events Processed: 373
Average Wait Time in Queue 2:   0.3740113539649861
Average Time in System 2:   0.54670174914003

当有两个队列时，队列2的等待时间将在处理队列1时增加。但是，上述模拟的结果是单独处理的结果，并且不考虑两个队列的服务率和到达率。

所以，我希望在交替处理两个队列时获得等待时间。如果有两个队列，如果正在处理队列1，则队列2的等待时间增加，如果正在处理队列2，则希望队列1的等待时间增加。

dequeue order）queue1-queue2-queue1-queue2 ....

感谢。 ：）