public static void main()

in kerby-tool/client-tool/src/main/java/org/apache/kerby/kerberos/tool/kinit/KinitToolWithConcurrence.java [155:272]
98 lines of code
23 McCabe index (conditional complexity)

    public static void main(String[] args) throws Exception {
        KinitOption kto;
        String principalNumbers = null;
        String startIndex = null;

        int i = 0;
        String opt, param, error;
        while (i < args.length) {
            error = null;

            opt = args[i++];
            if (opt.startsWith("-")) {
                kto = KinitOption.fromName(opt);
                if (kto == KinitOption.NONE) {
                    error = "Invalid option:" + opt;
                    System.err.println(error);
                    break;
                }
            } else {
                principalNumbers = opt;
                kto = KinitOption.NONE;
                // require a parameter
                startIndex = args[i++];
            }

            if (kto != KinitOption.NONE && kto.getOptionInfo().getType() != KOptionType.NOV) {
                // require a parameter
                param = null;
                if (i < args.length) {
                    param = args[i++];
                }
                if (param != null) {
                    KOptions.parseSetValue(kto.getOptionInfo(), param);
                } else {
                    error = "Option " + opt + " require a parameter";
                }
            }

            if (error != null) {
                printUsage(error);
            }
            if (kto != KinitOption.NONE) {
                ktOptions.add(kto);
            }
        }

        int threadNumbers = Integer.parseInt(principalNumbers);
        int stIndex = Integer.parseInt(startIndex);

        if (threadNumbers <= 0) {
            printUsage("principal must be greater than zero");
            System.exit(-1);
        }

        for (int j = 0; j < threadNumbers; j++) {
            int tmpIndex = j + stIndex;
            String tempName = "E" + tmpIndex + "@EXAMPLE.COM";
            prList[j] = tempName;
        }

        for (int j = 0; j < threadNumbers; j++) {
            Thread th = new Thread(new PreThread());
            th.start();
        }

        // statistical
        int[] tempDelayNumbers = new int[threadNumbers];
        int[] delayNumbers = new int[threadNumbers];
        startTime = System.currentTimeMillis();
        long timeStamp = System.currentTimeMillis();

        int max = 0;
        int min = 0;

        System.out.println("Time stamp (sec),Throughput (sec),"
                + "avgDelay (ms),maxDelay (ms),minDelay (ms)");

        while (true) {
            Thread.sleep(2000);
            int temp = 0;
            long now = System.currentTimeMillis();

            for (int j = 0; j < threadNumbers; j++) {
                delayNumbers[j] = reList[j * INTERVAL] - tempDelayNumbers[j];
                tempDelayNumbers[j] =  reList[j * INTERVAL];
            }

            for (int j = 0; j < threadNumbers; j++) {
                temp += reList[j * INTERVAL];
            }
            float res = (now - startTime) / (float) 1000;

            double totalDelay = 0.0;
            int cutThreads = 0;
            for (int j = 0; j < threadNumbers; j++) {
                if (delayNumbers[j] != 0) {
                    if (delayNumbers[max] < delayNumbers[j]) {
                        max = j;
                    }
                    if (delayNumbers[min] == 0 || delayNumbers[min] > delayNumbers[j]) {
                        min = j;
                    }
                    totalDelay += (now - startTime) * 1.0 / delayNumbers[j];
                } else {
                    cutThreads += 1;
                }
            }
            if (delayNumbers[min] != 0 && delayNumbers[max] != 0) {
                System.out.println((now - timeStamp) / 1000 + "," + (temp - tmpTotals) / res
                        + "," + (int) (totalDelay / (threadNumbers - cutThreads))
                        + "," + (now - startTime) / delayNumbers[min] + "," + (now - startTime) / delayNumbers[max]);
            }

            tmpTotals = temp;
            startTime = now;
        }

    }