public class ThreadStopExample {
    
    //Антипаттерн: Thread.stop()
    public static void badStop() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("Работаю...");
                // Если здесь stop() будет вызван, данные могут быть повреждены
            }
        });
        t.start();
        Thread.sleep(100);
        t.stop(); // Опасно! Освобождает мониторы, оставляя объекты в мусорном состоянии
    }
    
    //Правильно: кооперативное завершение через прерывание
    public static void goodInterrupt() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Безопасная работа...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // Восстанавливаем статус прерывания и выходим
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Поток корректно завершён");
        });
        t.start();
        Thread.sleep(2000);
        t.interrupt(); // Сигнал остановки
        t.join();
    }
    
    // Альтернатива: volatile флаг
    private volatile boolean running = true;
    
    public void safeWithFlag() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (running) {
                System.out.println("Работа с флагом...");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // При прерывании тоже можем выйти
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        running = false; // Сигнал остановки
        t.interrupt();   // Дополнительно для прерывания блокировок
        t.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        // badStop(); // Не запускайте!
        goodInterrupt();
    }
}

public class ThreadStopTricky {
    private static int value = 0;

    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            synchronized (ThreadStopTricky.class) {
                value = 1;
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                value = 2;
            }
        });
        t.start();
        Thread.sleep(50);
        t.stop();
        synchronized (ThreadStopTricky.class) {
            System.out.println(value);
        }
    }
}

public class DirectoryLister {
    
    public void listDirectory(Path dir) throws IOException {
        // Stream<Path> — ленивый поток, записи читаются по требованию
        try (Stream<Path> stream = Files.list(dir)) {
            stream.forEach(path -> {
                String type = Files.isDirectory(path) ? "[DIR]" : "[FILE]";
                System.out.println(type + " " + path.getFileName());
            });
        }
    }
}

public class TxtFileFinder {
    
    public void findTxtFiles(Path dir) throws IOException {
        try (Stream<Path> stream = Files.list(dir)) {
            stream.filter(Files::isRegularFile)           // только файлы, не директории
                  .filter(this::hasTxtExtension)           // фильтр по расширению
                  .forEach(this::printFileInfo);
        }
    }
    
    private boolean hasTxtExtension(Path path) {
        String fileName = path.getFileName().toString();
        // endsWith чувствителен к регистру — на case-sensitive ФС это корректно
        return fileName.endsWith(".txt");
    }
    
    private void printFileInfo(Path path) {
        try {
            long size = Files.size(path);
            FileTime modified = Files.getLastModifiedTime(path);
            System.out.printf("%s (%d bytes, modified: %s)%n",
                path.getFileName(), size, modified);
        } catch (IOException e) {
            System.err.println("Ошибка чтения атрибутов: " + path.getFileName());
        }
    }
    
    // Альтернатива: чтение атрибутов за один вызов для каждого файла
    public void findTxtFilesOptimized(Path dir) throws IOException {
        try (Stream<Path> stream = Files.list(dir)) {
            stream.filter(Files::isRegularFile)
                  .filter(p -> p.toString().endsWith(".txt"))
                  .map(p -> {
                      try {
                          BasicFileAttributes attrs = Files.readAttributes(
                              p, BasicFileAttributes.class
                          );
                          return new FileInfo(p.getFileName(), attrs.size(), 
                                            attrs.lastModifiedTime());
                      } catch (IOException e) {
                          return null;
                      }
                  })
                  .filter(Objects::nonNull)
                  .forEach(System.out::println);
        }
    }
    
    private record FileInfo(Path name, long size, FileTime modified) {}
}

функция list(Path dir) -> Stream<Path>:
    открыть файловый дескриптор директории dir (системный вызов opendir)
    создать DirectoryStream для чтения записей
    создать Stream, который при запросе следующего элемента:
        вызывает DirectoryStream.readNextEntry()
        если запись есть — возвращает Path(entry_name)
        если записей больше нет — закрывает дескриптор и завершает поток
    зарегистрировать onClose для Stream, который закрывает дескриптор
    вернуть Stream

public void walkDirectory(Path root) throws IOException {
    try (Stream<Path> stream = Files.walk(root)) {
        stream.forEach(path -> {
            int depth = root.relativize(path).getNameCount();
            String indent = "  ".repeat(depth);
            System.out.println(indent + path.getFileName());
        });
    }
}

public void walkWithDepthLimit(Path root) throws IOException {
    // Обходим только 2 уровня вглубь
    try (Stream<Path> stream = Files.walk(root, 2)) {
        stream.filter(Files::isRegularFile)
              .forEach(p -> System.out.println(p.toAbsolutePath()));
    }
}