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

        for (int i = 0; i < z; i++) {
            requirementSources.add(new RequirementSource(i, sourceLambda));
        }

        for (int i = 0; i < k; i++) {
            devices.add(new Device(i, serviceLambda));
        }

        QueueService queueService = new QueueService(b);

        double tmp = 0.0;

        while (queueService.getExecutedCount() < n) {
            Optional<RequirementSource> source = requirementSources.stream()
                                                                   .filter(RequirementSource::isAbleToGenerateRequirement)
                                                                   .min(Comparator.comparing(RequirementSource::getNextRequirementTime));

            Optional<Device> device = devices.stream()
                                             .filter(Device::isAbleToExecuteRequirement)
                                             .min(Comparator.comparing(Device::getNextExecuteTime));


            double reqInSystem = (queueService.queueSize() + devices.stream().filter(Device::isAbleToExecuteRequirement).count());
            if (source.isPresent() && device.isPresent()) {
                if (source.get().getNextRequirementTime() < device.get().getNextExecuteTime()) {
                    tmp += reqInSystem * (source.get().getNextRequirementTime() - currentTime);
                    currentTime = source.get().getNextRequirementTime();
                    source.get().createRequirement(queueService);
                } else {
                    tmp += reqInSystem * (device.get().getNextExecuteTime() - currentTime);
                    currentTime = device.get().getNextExecuteTime();
                    device.get().executeRequirement(queueService);
                }
            } else if (source.isPresent()) {
                tmp += reqInSystem * (source.get().getNextRequirementTime() - currentTime);
                currentTime = source.get().getNextRequirementTime();
                source.get().createRequirement(queueService);
            } else if (device.isPresent()) {
                tmp += reqInSystem * (device.get().getNextExecuteTime() - currentTime);
                currentTime = device.get().getNextExecuteTime();
                device.get().executeRequirement(queueService);
            }

            List<Device> availableDevices = devices.stream()
                                                   .filter(Device::isAbleToGetRequirement)
                                                   .collect(Collectors.toList());

            while (queueService.notEmpty() && availableDevices.size() > 0) {
                queueService.sendRequirement(availableDevices.get(0), currentTime);
                availableDevices = devices.stream()
                                          .filter(Device::isAbleToGetRequirement)
                                          .collect(Collectors.toList());
            }
        }

        double u = queueService.getExecutedRequirements().stream()
                               .map(x -> x.getTimeEndService() - x.getTimeExitSource())
                               .mapToDouble(a -> a)
                               .sum();


        System.out.println("U: " + u / n);
        System.out.println("N: " + tmp / currentTime);
    }