Code Review

public class Producer extends Thread {
    private final Logger logger = Logger.getLogger(Producer.class.getName());
    private final Queue<Integer> numbers;
    public Producer(Container queue) {
        this.numbers = queue.getQueue();
    }
        @Override
        public void run() {
            Scanner sc = new Scanner(System.in);
            int number = 0;
            try {
                while ((number = sc.nextInt()) != -1) {
                    numbers.add(number);
                }
            } catch (UserInputException e) {
                logger.info(e.getMessage());
            }
        }
}

public class Container {
    private Queue<Integer> queue = new LinkedList<>();
    public Queue<Integer> getQueue() {
        return queue;
    }
}

public Consumer(Container queue) {
        this.numbers = queue.getQueue();
        this.fileName = fileName;
    }

private final int milliseconds = 1000;
private final Queue<Integer> numbers;
private String fileName;
public static final Logger logger = Logger.getLogger(Consumer.class.getName());

public void run() {
    try (FileWriter fileWriter = new FileWriter(fileName, true)) {
        for (int number : numbers) {
            try {
                Thread.sleep(number * milliseconds);
                fileWriter.write(LocalDateTime.now() + "-" + Thread.currentThread().getName() + "- I slept " + milliseconds / 1000 + " seconds.\n");
            } catch (InterruptedException e) {
                logger.info("Work interrupted");
            }
            fileWriter.write(LocalDateTime.now() + "-" + Thread.currentThread().getName() + "- ...\n");
        }
    } catch (IOException e) {
        logger.info(e.getMessage());
    }
}

public class QueueInput {
    private Queue<Integer> queueInput = new LinkedList<>();

    public synchronized Queue<Integer> getQueue() {
        return queueInput;
    }

    public synchronized void addQueue(Integer integer) {
        queueInput.add(integer);
    }
}

public class DemoProducerConsumer {
    public static void main(String[] args) {
        Thread producer = new Thread(new Producer());
        Thread consumer1 = new Thread(new Consumer());
        Thread consumer2 = new Thread(new Consumer());
        Thread consumer3 = new Thread(new Consumer());
        producer.start();

        try {
            producer.join();
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

while (!Thread.currentThread().isInterrupted()) {
    try {
        String inputString = scanner.nextLine();
        try {
            int parsedInteger = Integer.parseInt(inputString);
            if (parsedInteger != -1) {
                queueInputProducer.addQueue(parsedInteger);
                logger.info(String.valueOf(parsedInteger));
            } else {
                Thread.currentThread().interrupt();
                scanner.close();
                return;
            }
        } catch (NumberFormatException exception) {
            throw new UserInputException("Input value should be Integer");
        }
    } catch (Exception exception) {
        logger.info(exception.getMessage());
    }
}

while (true) {
    for (Integer seconds : queueInputConsumer.getQueue()) {
        String file = "";
        if (seconds != null) {
            try {
                Thread.sleep(Math.abs(seconds) * MILLS);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            String timeStamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date());
            String infoMessage = String.format("%s - %s - I slept %d seconds.", timeStamp, Thread.currentThread().getName(), seconds);
            try {
                FileWriter fileWriter = new FileWriter(file, true);
                fileWriter.write(infoMessage);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        } else {
            try {
                String timeStamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date());
                String infoMessage = String.format("%s - %s - ...", timeStamp, Thread.currentThread().getName());
                try {
                    FileWriter fileWriter = new FileWriter(file, true);
                    fileWriter.write(infoMessage);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class BackupUtility {
    public void copy(String finalDirectory, String initialDirectory) {
        try {
            File fileFinalDirectory = new File(finalDirectory);
            File[] arrayWithFiles = fileFinalDirectory.listFiles();
            Path copiedDir = Paths.get(initialDirectory);

            if (arrayWithFiles != null) {
                for (File file : arrayWithFiles) {
                    Files.copy(file.toPath(), copiedDir.resolve(file.getName()), StandardCopyOption.REPLACE_EXISTING);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Producer extends Thread {
    private final Queue<Integer> numbers;

    public Producer(Container queue) {
        this.numbers = queue.getQueue();
    }

    public static final Logger logger = Logger.getLogger(Producer.class.getName());

   @Override
   public void run() {
       Scanner sc = new Scanner(System.in);
        int number;
        try {
            while ((number = sc.nextInt()) != -1) {
             numbers.add(number);
            }
        } catch (UserInputException e) {
            logger.info(e.getMessage());
        }
    }
}

file: testFile.txt

2022-11-06T12:52:14.619166400 - Thread-2 - ...
2022-11-06T12:52:16.620039500 - Thread-2 - I slept 2 seconds
2022-11-06T12:52:16.620039500 - Thread-2 - ...
2022-11-06T12:52:19.621381900 - Thread-2 - I slept 3 seconds
2022-11-06T12:52:19.622361700 - Thread-2 - ...
2022-11-06T12:52:14.609159700 - Thread-3 - I slept 1 seconds
2022-11-06T12:52:14.621168400 - Thread-3 - ...
2022-11-06T12:52:16.622021 - Thread-3 - I slept 2 seconds
2022-11-06T12:52:16.623021300 - Thread-3 - ...
2022-11-06T12:52:19.627366800 - Thread-3 - I slept 3 seconds

public class Producer_Queue_ConsumerDemo {
    public static void main(String[] args) {
        String fileName = "src/test/java/com/rakovets/course/java/core/practice/concurrency/testFile.txt";
        Container numbers = new Container();
        Thread producerThread = new Producer(numbers);
        Thread consumer1 = new Consumer(numbers, fileName);
        Thread consumer2 = new Consumer(numbers, fileName);
        Thread consumer3 = new Consumer(numbers, fileName);
        producerThread.start();
        try {
            producerThread.join();
        } catch (InterruptedException e) {
            System.out.println(e);;
        }
        consumer1.start();
        consumer2.start();
        consumer3.start();
    }
}

public final class QueueContainer {
    private QueueContainer() {
    }

    private static final Queue<Integer> queue = new LinkedList<>();

    public synchronized static void addItem(Integer item) {
        queue.add(Math.abs(item));
    }

    public synchronized static Integer getItem() {
        return queue.poll();
    }
}

public class Producer implements Runnable {
    private final Logger logger = Logger.getLogger(this.getClass().getName());

    @Override
    public void run() {
        Scanner scanner = new Scanner(System.in);
        logger.log(Level.INFO, "Enter one integer: ");

        while (true) {
            try {
                String numberStr = scanner.nextLine();
                try {
                    int number = Integer.parseInt(numberStr);
                    if (number != -1) {
                        QueueContainer.addItem(number);
                    } else {
                        logger.log(Level.INFO, "Producer was closed ");
                        scanner.close();
                        return;
                    }
                } catch (NumberFormatException e) {
                    throw new UserInputException("Warning! Enter only integer numbers!");
                }
            } catch (UserInputException e) {
                logger.log(Level.SEVERE, "ERROR " + e.getMessage());
            }
        }
    }
}

public final class FileHelper {
    private FileHelper() {
    }

    private static String FILE_NAME = "";

    public static void setFilename(final String filename) {
        FILE_NAME = filename;
    }

    public synchronized static void addLineToFile(final String line) {
        try {
            Files.write(
                    Paths.get(FILE_NAME),
                    (line + "\n").getBytes(),
                    StandardOpenOption.APPEND);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

import java.sql.Timestamp;

public class Consumer implements Runnable {
    @Override
    public void run() {
        while (true) {
            Integer value = QueueContainer.getItem();

            if (value != null) {
                try {
                    Thread.sleep(value * 1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                Timestamp timestamp = new Timestamp(System.currentTimeMillis());
                FileHelper.addLineToFile(timestamp + " - " + Thread.currentThread().getName() + " - I slept " + value + " seconds\n");
            } else {
                try {
                    Timestamp timestamp = new Timestamp(System.currentTimeMillis());
                    FileHelper.addLineToFile(timestamp + " - " + Thread.currentThread().getName() + " - ...");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public abstract class Files {
    public static File OUTPUT_FILE = new File("src" + File.separator
            + "test" + File.separator
            + "java" + File.separator
            + "com" + File.separator
            + "rakovets" + File.separator
            + "course" + File.separator
            + "java" + File.separator
            + "core" + File.separator
            + "practice" + File.separator
            + "concurrency" + File.separator
            + "output.txt" + File.separator);
}

public class Container {
    private final Queue<Integer> queue1 = new LinkedList<>();

    public Queue<Integer> getQueue() {
        return queue1;
    }
}

public class Consumer extends Thread {
    private final int MILLS = 1000;
    private final Queue<Integer> numbers;

    public Consumer(Container queue) {
        this.numbers = queue.getQueue();
    }

    @Override
    public void run() {
        try {
            FileWriter writer = new FileWriter("D://IT/Courses IT Academy/course-java-core/src/main/java/com/rakovets/course/java/core/practice/concurrency/ProducerConsumer.txt",
                    true);
            while (!Thread.currentThread().isInterrupted()) {
                if (!numbers.isEmpty()) {
                    long seconds = numbers.poll();
                    Thread.sleep(seconds * MILLS);
                    writer.write(LocalDateTime.now() + "-" + Thread.currentThread().getName() + "- I slept " +
                            seconds + " seconds.\n");
                    writer.flush();
                } else {
                    writer.write(LocalDateTime.now() + "-" + Thread.currentThread().getName() + "- ...\n");
                    writer.flush();
                    Thread.sleep(MILLS);
                    break;
                }
            }
        } catch (NullPointerException | IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Override
public void run() {
    Scanner sc = new Scanner(System.in);
    logger.info("Enter a number: ");
    while (isActive) {
        try {
            int number = Integer.parseInt(sc.nextLine());
            if (number != -1) {
                numbers.add(number);
            } else {
                new Producer().disable();
                logger.info("The program finished");
                break;
            }
        } catch (UserInputException | IllegalArgumentException e) {
            logger.warning("Sorry! This is inappropriate value!" + e.getMessage());
            logger.severe(Arrays.toString(e.getStackTrace()));
        }
    }
    sc.close();
}

while (!queue.getQueueNumbers().isEmpty()) {
    if (!queue.getQueueNumbers().isEmpty()) {
        int numberQueue = (int)queue.getQueueNumbers().poll();
        Thread.sleep(numberQueue * MILLS_IN_SECOND);
        writer.write(timestamp +
                " - " + Thread.currentThread().getName() +
                " - " + "I slept " + numberQueue + " seconds");
        writer.newLine();
        writer.flush();
    } else {
        writer.write(timestamp +
                " - " + Thread.currentThread().getName() +
                " - " + "...");
        writer.newLine();
        writer.flush();
        Thread.sleep(MILLS_IN_SECOND);
    }
}