public class InheritableThreadLocalPitfall {
    
    //Опасно: InheritableThreadLocal в пуле
    private static final InheritableThreadLocal<String> USER_CONTEXT = 
        new InheritableThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // Главный поток устанавливает контекст
        USER_CONTEXT.set("Admin");
        
        // Задача, которая пытается получить унаследованное значение
        executor.submit(() -> {
            // Выведет "Admin", даже если ожидается другой контекст
            System.out.println("Task 1 - inherited: " + USER_CONTEXT.get());
        });
        
        // Меняем контекст перед новой задачей в главном потоке
        USER_CONTEXT.set("Guest");
        executor.submit(() -> {
            // Выведет "Guest" (текущее значение главного потока)
            System.out.println("Task 2 - inherited: " + USER_CONTEXT.get());
        });
        
        // В реальности пул создан один раз, и значения берутся из главного
        // потока в момент создания пула или подачи задачи? На самом деле 
        // наследование происходит при создании потока, а не при submit.
        // В данном примере потоки уже созданы, поэтому унаследованных значений нет.
        // Это показывает, что наследование происходит только при создании потока.
        
        // Если создать новый пул внутри другой задачи, то контекст унаследуется
        // от родительской задачи, что тоже опасно.
        executor.shutdown();
    }
}

//Безопасный подход: явная передача контекста
public class SafeThreadLocal {
    
    private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();
    
    public static void executeWithContext(ExecutorService executor, 
                                          String user, Runnable task) {
        executor.submit(() -> {
            try {
                CONTEXT.set(user);
                task.run();
            } finally {
                CONTEXT.remove(); // обязательная очистка
            }
        });
    }
    
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executeWithContext(executor, "Admin", () -> {
            System.out.println("Working as: " + CONTEXT.get());
        });
        executor.shutdown();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Task060726 {
    private static final InheritableThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

    public static void main(String[] args) {
        threadLocal.set("main");
        ExecutorService executor = Executors.newFixedThreadPool(1);

        for (int i = 0; i < 3; i++) {
            final int taskId = i;
            executor.submit(() -> {
                if (threadLocal.get() == null) {
                    threadLocal.set("task" + taskId);
                }
                System.out.print(threadLocal.get() + " ");
            });
        }
        executor.shutdown();
    }
}

import java.nio.file.Path;
import java.nio.file.Paths;

// Linux / macOS
Path linuxPath = Paths.get("/home/user/documents/report.txt");

// Windows
Path windowsPath = Paths.get("C:\\Users\\Admin\\file.txt");

Path path = Paths.get("/home", "user", "documents", "report.txt");
// Результат: /home/user/documents/report.txt

Path relative = Paths.get("src", "main", "java", "App.java");
// Результат: src/main/java/App.java (на Unix) или src\main\java\App.java (на Windows)

import java.nio.file.FileSystems;

Path path = FileSystems.getDefault().getPath("/tmp", "data.txt");

Path p = Paths.get("/home/user/file.txt");
System.out.println(p.toString());
// Вывод: /home/user/file.txt

Path p = Paths.get("/home/user/documents/report.txt");
Path fileName = p.getFileName();  // report.txt

Path dir = Paths.get("/home/user/documents");
Path dirName = dir.getFileName();  // documents

Path p = Paths.get("/home/user/documents/report.txt");
Path parent = p.getParent();  // /home/user/documents

Path root = Paths.get("/");
Path rootParent = root.getParent();  // null

Path absolute = Paths.get("/home/user/file.txt");
Path root = absolute.getRoot();  // /

Path relative = Paths.get("src/main/java");
Path relRoot = relative.getRoot();  // null

Path p = Paths.get("/home/user/documents/report.txt");
int count = p.getNameCount();  // 4 (home, user, documents, report.txt)

Path p = Paths.get("/home/user/documents/report.txt");
Path segment = p.getName(1);  // user

Path p = Paths.get("/home/user/documents/report.txt");
Path sub = p.subpath(1, 3);  // user/documents

Path abs = Paths.get("/etc/passwd");
boolean isAbs = abs.isAbsolute();  // true

Path rel = Paths.get("config/app.properties");
boolean isRel = rel.isAbsolute();  // false

Path rel = Paths.get("config/app.properties");
Path abs = rel.toAbsolutePath();
// Результат: /current/working/dir/config/app.properties

Path p = Paths.get("/home/user/../documents/./report.txt");
Path norm = p.normalize();  // /home/documents/report.txt

Path base = Paths.get("/home/user");
Path resolved = base.resolve("documents/report.txt");
// Результат: /home/user/documents/report.txt

Path base = Paths.get("/home/user");
Path target = Paths.get("/home/user/documents/report.txt");
Path rel = base.relativize(target);  // documents/report.txt

Path p = Paths.get("/home/user/documents");
boolean starts = p.startsWith(Paths.get("/home"));     // true
boolean ends = p.endsWith(Paths.get("documents"));     // true

Path path = Paths.get("/tmp/data.txt");
java.io.File legacyFile = path.toFile();

Path p = Paths.get("/home/user/file.txt");
for (Path segment : p) {
    System.out.println(segment);
}
// Вывод: home, user, file.txt

Path p1 = Paths.get("/a/b/c");
Path p2 = Paths.get("/a/b/d");
int result = p1.compareTo(p2);  // отрицательное число (c < d)

import java.nio.file.*;
import java.io.IOException;

public class DirectoryScanner {
    public static void scanDirectory(Path root) throws IOException {
        // Files.walk — рекурсивный обход дерева директорий
        try (Stream<Path> paths = Files.walk(root, 3)) {  // глубина 3 уровня
            paths.filter(Files::isRegularFile)           // только файлы
                 .filter(p -> p.toString().endsWith(".java"))
                 .forEach(p -> System.out.println(p.toAbsolutePath()));
        }
    }
}

public class ConfigResolver {
    private final Path baseDir;
    
    public ConfigResolver(String basePath) {
        this.baseDir = Paths.get(basePath).toAbsolutePath().normalize();
    }
    
    public Path resolveConfig(String configName) {
        // resolve объединяет baseDir с относительным путём
        Path resolved = baseDir.resolve("config").resolve(configName);
        
        // безопасность: проверяем, что результирующий путь всё ещё внутри baseDir
        if (!resolved.startsWith(baseDir)) {
            throw new SecurityException("Path traversal attempt detected");
        }
        return resolved;
    }
}

public void safeCopy(Path source, Path target) throws IOException {
    // normalize убирает . и .. перед проверкой
    Path normalizedSource = source.toAbsolutePath().normalize();
    Path normalizedTarget = target.toAbsolutePath().normalize();
    
    // getParent возвращает директорию назначения
    Path targetDir = normalizedTarget.getParent();
    if (targetDir != null && !Files.exists(targetDir)) {
        Files.createDirectories(targetDir);  // создаём всю цепочку директорий
    }
    
    // StandardCopyOption — перечисление, определяющее поведение копирования
    Files.copy(normalizedSource, normalizedTarget, 
               StandardCopyOption.REPLACE_EXISTING,
               StandardCopyOption.COPY_ATTRIBUTES);
}

public Path createTempFileWithPath() throws IOException {
    // getDefault() возвращает файловую систему по умолчанию
    Path tempDir = FileSystems.getDefault().getPath(System.getProperty("java.io.tmpdir"));
    
    // createTempFile создаёт файл с префиксом и суффиксом
    Path tempFile = Files.createTempFile(tempDir, "app_", ".tmp");
    
    System.out.println("Created: " + tempFile.toAbsolutePath());
    return tempFile;
}

import java.nio.file.Path;
import java.nio.file.Paths;

public class Task070726 {
    public static void main(String[] args) {
        Path p1 = Paths.get("/foo");
        Path p2 = Paths.get("/bar");
        Path p3 = p1.resolve(p2);
        Path p4 = p1.resolve("bar");
        System.out.print(p3 + " " + p4);
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class ReentrantLockFinally {
    
    private final ReentrantLock lock = new ReentrantLock();
    
    //Антипаттерн: без finally — риск deadlock
    public void badMethod() {
        lock.lock();
        // Если здесь произойдет исключение, lock не освободится
        doWork();
        lock.unlock(); // Может не выполниться
    }
    
    //Правильно: try-finally
    public void goodMethod() {
        lock.lock();
        try {
            doWork();
        } finally {
            lock.unlock(); // Гарантированно вызовется
        }
    }
    
    //tryLock с таймаутом
    public boolean tryLockWithTimeout() throws InterruptedException {
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                doWork();
                return true;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Не удалось захватить блокировку");
            return false;
        }
    }
    
    //Использование Condition (тоже с finally)
    public void conditionExample() throws InterruptedException {
        var condition = lock.newCondition();
        lock.lock();
        try {
            condition.await(1, TimeUnit.SECONDS);
        } finally {
            lock.unlock();
        }
    }
    
    private void doWork() {
        // критическая секция
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class Task080726 {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            lock.lock();
            System.out.println("Thread1 acquired lock");
        });

        Thread t2 = new Thread(() -> {
            try {
                if (lock.tryLock(1, TimeUnit.SECONDS)) {
                    System.out.println("Thread2 acquired lock");
                    lock.unlock();
                } else {
                    System.out.println("Thread2 failed to acquire lock");
                }
            } catch (InterruptedException e) {
                System.out.println("Interrupted");
            }
        });

        t1.start();
        Thread.sleep(100);
        t2.start();
        t2.join();
    }
}

java.io.File oldFile = new java.io.File("/etc/shadow");
boolean deleted = oldFile.delete();  // false — но почему? Нет прав? Файл занят? Файла нет?

Path configPath = Paths.get("/app/config.properties");
boolean exists = Files.exists(configPath);

Path secret = Paths.get("/root/.ssh/id_rsa");

if (Files.notExists(secret)) {
    // Мы уверены, что файла нет (или нет прав, но тогда exists тоже вернул бы false)
    System.out.println("Файл не существует");
} else if (Files.exists(secret)) {
    // Мы уверены, что файл есть
    System.out.println("Файл существует");
} else {
    // Files.exists() == false И Files.notExists() == false
    // Это возможно только при ошибке доступа — состояние неопределённости
    System.out.println("Невозможно определить существование файла");
}