Тестирование протокола отказов

Я работаю над школьным проектом, в котором мне требуется разработать и протестировать протокол отсрочки. Я должен игнорировать параллелизм и, с определенным количеством узлов, проверять требуемую задержку, чтобы каждый узел отправлял свой единственный пакет.

Я начинаю со 100 узлов и тестирую 4 разных типа отсрочки. Я использую slotChosen yo выбрать случайный слот окна, если два узла выбирают один и тот же слот, чем я столкнулся, и два узла должны отправить пакет снова. Каждый раз, когда у меня есть некоторые узлы, которые все еще должны отправлять свой пакет, я увеличиваю окно и увеличиваю время ожидания.

Это мой код:

public class myBackoff {

    public static void main(String[] args) throws IOException {

        int n; // number of devices
        int times;
        int latency = 0;
        int[] slotChosen;
        int[] status;
        boolean success;

        BufferedWriter linearFile = new BufferedWriter (new FileWriter("linearLatency.txt"));
        BufferedWriter binaryFile = new BufferedWriter (new FileWriter("binaryLatency.txt"));
        BufferedWriter trinaryFile = new BufferedWriter (new FileWriter("trinaryLatency.txt"));
        BufferedWriter loglogFile = new BufferedWriter (new FileWriter("loglogLatency.txt"));

        for ( n = 100 ; n <= 1000 ; n += 100) {

            // linearLatency
            slotChosen = new int [n];
            status = new int[n];
            success = false;

            times = 0;
            latency = 0;
            while ( times < 10) {

                Initialize(slotChosen, n);
                Initialize(status, n);
                latency += Latency(success, status, slotChosen, 2, n, 1);
                times++;

            }
            linearFile.write(latency/10 + " ");

            // binaryLatency
            success = false;
            times = 0;
            latency = 0;
            while ( times < 10) {

                Initialize(slotChosen, n);
                Initialize(status, n);
                latency += Latency(success, status, slotChosen, 2, n, 2);
                times++;

            }
            binaryFile.write(latency/10 + " ");

            // trinaryLatency
            success = false;
            times = 0;
            latency = 0;
            while ( times < 10) {

                Initialize(slotChosen, n);
                Initialize(status, n);
                latency += Latency(success, status, slotChosen, 3, n, 3);
                times++;

            }
            trinaryFile.write(latency/10 + " ");

            //loglogLatency
            success = false;
            times = 0;
            latency = 0;
            while ( times < 10) {

                Initialize(slotChosen, n);
                Initialize(status, n);
                latency += Latency(success, status, slotChosen, 4, n, 4);
                times++;

            }
            loglogFile.write(latency/10 + " ");

        }

        linearFile.close();
        binaryFile.close();
        trinaryFile.close();
        loglogFile.close();

    }

    public static int Latency(boolean success, int[] status, int[] slotChosen, int window, int n, int type){

        int latency = 0;

        while (success == false) {

            success = true;
            System.out.println(window + " " + n);
            for ( int t = 0 ; t < n ; t++ ) { // choosing a random slot for each node

                if (status[t] == 0) {

                    Random r = new Random();
                    slotChosen[t] = r.nextInt(window) + 1;
                    System.out.println(slotChosen[t]);
                    status[t] = 1;

                } else {

                    System.out.println("success");
                    slotChosen[t] = 0;

                }

            }

            for ( int t = 0 ; t < n ; t++ ) {

                for ( int i = 0 ; i < n ; i++ ) { // searching for collision

                    if (slotChosen[t] == slotChosen[i] && t != i) {

                        status[t] = status[i] = 0; //collision detected

                    }

                }

            }

            for ( int t = 0 ; t < n ; t++ ) { // still node unsuccessful

                if (status[t] == 0) {

                    success = false;
                    break;

                }

            }

            if (success == true) {

                int max = 0;
                for ( int t = 0 ; t < n ; t++ ) { // last latency addition

                    if (slotChosen[t] != 0 && slotChosen[t] > max) {

                        max = slotChosen[t];

                    }

                }
                latency += max;

            } else {

                latency += window;

            }

            switch(type) {

            case 1: window ++;
                    break;
            case 2: window = window * 2;
                    break;
            case 3: window = window * 3;
                    break;
            case 4: window = (int) Math.floor(((1+1/(Math.log(Math.log(window))))*window));
                    break;
            }

        }

        return latency;

    }

    public static void Initialize (int[] array, int n) {

        for ( int t = 0 ; t < n ; t++ ) {

            array[t] = 0;

        }

    }

}

Дело в том, что я позволяю моему коду работать более 10 минут без вывода. Я думаю, что есть что-то не так, но не могу понять, что.