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()));
    }
}

public class SafeWalker {
    
    // Безопасный обход: символические ссылки обрабатываются как файлы, не следуем по ним
    public void walkNoFollowLinks(Path root) throws IOException {
        // По умолчанию walk НЕ следует по ссылкам — это поведение по умолчанию
        // Но явно можно указать:
        try (Stream<Path> stream = Files.walk(root)) {
            stream.forEach(path -> {
                if (Files.isSymbolicLink(path)) {
                    System.out.println("[LINK] " + path.getFileName());
                }
            });
        }
    }
    
    // Обход с явным следованием по ссылкам (осторожно!)
    public void walkFollowingLinks(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root, FileVisitOption.FOLLOW_LINKS)) {
            stream.forEach(System.out::println);
        }
    }
}

функция walk(Path start, int maxDepth) -> Stream<Path>:
    создать очередь (Deque) для обхода в ширину/глубину
    поместить start в очередь с глубиной 0
    создать Stream, который при запросе элемента:
        извлекает следующий путь из очереди
        возвращает его как элемент Stream
        если это директория И глубина < maxDepth:
            открыть DirectoryStream для этой директории
            для каждой записи:
                поместить entry в очередь с глубиной + 1
    зарегистрировать onClose для закрытия всех открытых DirectoryStream
    вернуть Stream

// ОПАСНО: материализует все пути в память
Files.walk(root).sorted().forEach(...);  // OOM при миллионе файлов

// Безопасно: обход без сортировки
Files.walk(root).forEach(...);  // ленивый, память ограничена буфером

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;

public class ControlledTreeWalker implements FileVisitor<Path> {
    
    private final AtomicLong totalSize = new AtomicLong(0);
    private final long maxSizeToProcess;  // прервать после достижения лимита
    private volatile boolean cancelled = false;
    
    public ControlledTreeWalker(long maxSize) {
        this.maxSizeToProcess = maxSize;
    }
    
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        if (cancelled) {
            return FileVisitResult.TERMINATE;  // прервать обход
        }
        // Пропускаем скрытые директории
        try {
            if (Files.isHidden(dir)) {
                return FileVisitResult.SKIP_SUBTREE;  // не заходить внутрь
            }
        } catch (IOException e) {
            // Продолжаем, если не удалось проверить
        }
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        if (cancelled) {
            return FileVisitResult.TERMINATE;
        }
        if (attrs.isRegularFile()) {
            totalSize.addAndGet(attrs.size());
            if (totalSize.get() >= maxSizeToProcess) {
                cancelled = true;
                return FileVisitResult.TERMINATE;
            }
        }
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
        // Логируем ошибку, но продолжаем обход
        System.err.println("Ошибка доступа к файлу: " + file + " — " + exc.getMessage());
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
        if (exc != null) {
            System.err.println("Ошибка обхода директории: " + dir + " — " + exc.getMessage());
        }
        return FileVisitResult.CONTINUE;
    }
    
    public long getTotalSize() {
        return totalSize.get();
    }
    
    public static long calculateSizeWithLimit(Path root, long limit) throws IOException {
        ControlledTreeWalker walker = new ControlledTreeWalker(limit);
        Files.walkFileTree(root, walker);
        return walker.getTotalSize();
    }
}