ScheduledExecutorService - сбор статистики

public class Account {
 
    private int balance;
 
    private final Lock lock = new ReentrantLock();
 
    /*счетчик неудачных транзакций*/
    private AtomicInteger failCounter = new AtomicInteger(1);
 
 
    public Account(int balance) {
        this.balance = balance;
    }
 
    /*увеличение счетчика неудачных транзакций*/
    public void incrementFailedTransferCounter() {
        this.failCounter.incrementAndGet();
    }
 
    public AtomicInteger getFailCounter() {
        return failCounter;
    }
 
    public Lock getLock() {
        return lock;
    }
 
    /*пополенение счета*/
    public void depositToAccount(final int amount) {
        balance += amount;
    }
 
    /*списание денег с указанного счета*/
    public void withdrawFromAccount(final int amount) {
        balance -= amount;
    }
 
    public int getBalance() {
        return balance;
    }
}

public class Transfer implements Callable<Boolean> {
 
 
    private static final Logger LOGGER =
            LoggerFactory.getLogger(Transfer.class);
 
    private final Account accountFrom;
    private final Account accountTo;
    private final int amount;
    private final int idThread;
 
 
    public Transfer(Account accountFrom, Account accountTo, int amount, int idThread) {
        this.accountFrom = accountFrom;
        this.accountTo = accountTo;
        this.amount = amount;
        this.idThread = idThread;
    }
 
    private final Random waitRandom = new Random();
 
    @Override
    public Boolean call() throws Exception  {
 
        while (true) {
            try {
                boolean isTryLockAccountFrom = accountFrom.getLock().tryLock(LOCK_WAIT_SEC, TimeUnit.SECONDS);
 
                if (isTryLockAccountFrom) {
 
                    boolean isTryLockAccountTo = accountTo.getLock().tryLock(LOCK_WAIT_SEC, TimeUnit.SECONDS);
 
                    if (isTryLockAccountTo) {
                        try {
 
                            if (accountFrom.getBalance() < amount) {
 
                             throw new InsufficientResourcesAccountException("На счету недостаточно денег.");
 
                            }
 
                            accountFrom.withdrawFromAccount(amount);/*списание со счета*/
                            LOGGER.warn("--- Поток № : " + this.idThread);
                            LOGGER.warn("Деньги списаны со счета. Остаток (accountFrom) : "
                                    + accountFrom.getBalance());
 
                            accountTo.depositToAccount(amount);/*пополнение счета*/
                            LOGGER.warn("Деньги зачислены на счет. Остаток (accountTo) : " + accountTo.getBalance());
                            LOGGER.warn("\n");
                            Thread.sleep(waitRandom.nextInt(2000));
 
                            return true;
                        } finally {
                            accountTo.getLock().unlock();
                        }
                    } else {
                        accountTo.incrementFailedTransferCounter();
                        return false;
                    }
                } else {
                    accountFrom.incrementFailedTransferCounter();
                    return false;
                }
            } catch (InterruptedException e) {
                LOGGER.error("Время ожидания попытки" +
                        " захвата блокировки объекта 'isLockAccountTo' - превышено!");
            } finally {
                accountFrom.getLock().unlock();
            }
        }
    }
}

public class TransferRun {
 
    private final static long timeout = 100000;
    private final static TimeUnit unit = TimeUnit.SECONDS;
 
    public static void main(String[] args) throws InterruptedException {
 
        Account accountFrom = new Account(1000);
 
        Account accountTo = new Account(2000);
 
        ExecutorService executorService = Executors.newFixedThreadPool(3);
 
        Random random = new Random();
 
        List<Future<Boolean>> transfersFutureList = new ArrayList<>();
 
        IntStream.range(0, 10)
                .forEach(i -> {
 
                    int sumForTransfer = random.nextInt(400);
 
                    Transfer transfer = new Transfer(accountFrom, accountTo, sumForTransfer, i);
                    Future<Boolean> booleanFuture = executorService.submit(transfer);
 
                    transfersFutureList.add(booleanFuture);
                });
 
        executorService.shutdown();
 
        runScheduleForGettingFailedLocking(accountFrom, accountTo);
 
        /*указываем, сколько времени нужно ждать,
        чтобы все потоки смогли выполниться  */
        try {
            executorService.awaitTermination(timeout, unit);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
 
        showResultFromCallable(transfersFutureList);
    }
 
    private static void runScheduleForGettingFailedLocking(Account accountFrom, Account accountTo) throws InterruptedException {
 
        ScheduledExecutorService scheduledExecutorService  =
                Executors.newScheduledThreadPool(2);
 
        Thread threadAccountFrom = new Thread(() -> {
            AtomicInteger failCounter = accountFrom.getFailCounter();
            System.out.println("Количество неудачных попыток захвата монитора для `accountFrom`:"
                    + failCounter);
        });
 
        scheduledExecutorService
                .scheduleAtFixedRate(threadAccountFrom, 1, 2, TimeUnit.SECONDS);
 
        Thread threadAccountTo = new Thread(() -> {
            AtomicInteger failCounter = accountTo.getFailCounter();
            System.out.println("Количество неудачных попыток захвата монитора для `accountTo`:"
                    + failCounter);
        });
 
 
        scheduledExecutorService
                .scheduleAtFixedRate(threadAccountTo, 1, 2, TimeUnit.SECONDS);
 
        scheduledExecutorService.shutdown();
 
 
        scheduledExecutorService.awaitTermination(timeout, unit);
    }
 
    private static void showResultFromCallable(List< Future<Boolean>> transfersFutureList) {
 
        final List<Boolean> list = new ArrayList<>();
 
        List<Boolean> booleanList = transfersFutureList
                .stream()
                .map(booleanFuture -> {
 
                    Boolean isGetLock;
                    try {
                        isGetLock = booleanFuture.get();
                        list.add(isGetLock);
                    } catch (InterruptedException e) {
                        list.add(false);
                       // e.printStackTrace();
                    } catch (ExecutionException e) {
                        list.add(false);
                       // e.printStackTrace();
                    }
                    return list;
 
                })
                .flatMap(List::stream)
                .collect(Collectors.toList());
                 System.out.println(booleanList);
    }
 
}