import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;
import java.time.Instant;

public class FileToucher {
    
    public void touch(Path path) throws IOException {
        if (Files.notExists(path)) {
            // Если файла нет — создаём пустой файл
            // и время модификации будет равно времени создания (сейчас)
            Files.createFile(path);
            System.out.println("Файл создан: " + path);
            return;
        }
        
        // Файл существует — обновляем только время модификации
        FileTime now = FileTime.from(Instant.now());
        Files.setLastModifiedTime(path, now);
        
        // Проверяем, что установилось
        FileTime verify = Files.getLastModifiedTime(path);
        if (verify.compareTo(now) >= 0) {
            System.out.println("Время модификации обновлено: " + verify);
        } else {
            throw new IOException("Не удалось обновить время модификации");
        }
    }
    
    public void touchWithAccessTime(Path path) throws IOException {
        // Обновляем и время модификации, и время доступа
        FileTime now = FileTime.from(Instant.now());
        
        Files.setAttribute(path, "basic:lastModifiedTime", now);
        Files.setAttribute(path, "basic:lastAccessTime", now);
        
        // Проверяем через readAttributes
        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
        System.out.println("mtime: " + attrs.lastModifiedTime());
        System.out.println("atime: " + attrs.lastAccessTime());
    }
    
    public static void main(String[] args) {
        try {
            Path file = Paths.get("/tmp/test_touch.txt");
            new FileToucher().touch(file);
        } catch (IOException e) {
            System.err.println("Ошибка: " + e.getMessage());
        }
    }
}

// Проблемный код: храним все атрибуты в памяти
Map<Path, BasicFileAttributes> cache = new HashMap<>();
Files.walk(root).forEach(p -> {
    try {
        cache.put(p, Files.readAttributes(p, BasicFileAttributes.class));
    } catch (IOException e) { /* ignore */ }
});
// При миллионе файлов cache содержит миллион объектов BasicFileAttributes в Old Generation

// Оптимизированный код: извлекаем только размер и mtime, храним примитивы
Map<Path, Long> sizeCache = new HashMap<>();
Files.walk(root).forEach(p -> {
    try {
        BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);
        sizeCache.put(p, attrs.size());  // только long, лёгкий объект
    } catch (IOException e) { /* ignore */ }
});
// Объект attrs становится мусором сразу после итерации

// Обход с минимальным потреблением памяти
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for (Path entry : stream) {
        BasicFileAttributes attrs = Files.readAttributes(entry, BasicFileAttributes.class);
        process(entry, attrs.size(), attrs.lastModifiedTime());
        // attrs собирается GC сразу после process()
    }
}

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.*;

public class Task170726 {
    public static void main(String[] args) throws IOException, InterruptedException {
        Path path = Paths.get("test.txt");
        Files.write(path, "ABC".getBytes());
        
        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
        long size1 = attrs.size();
        long modified1 = attrs.lastModifiedTime().toMillis();
        
        Thread.sleep(2000);
        Files.write(path, "ABCDE".getBytes(), StandardOpenOption.TRUNCATE_EXISTING);
        
        long size2 = attrs.size();
        long modified2 = attrs.lastModifiedTime().toMillis();
        
        BasicFileAttributes attrsNew = Files.readAttributes(path, BasicFileAttributes.class);
        long size3 = attrsNew.size();
        long modified3 = attrsNew.lastModifiedTime().toMillis();
        
        System.out.println(size1 + " " + size2 + " " + size3);
        System.out.println(modified1 == modified2);
        System.out.println(modified1 == modified3);
    }
}

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