import java.util.concurrent.CompletableFuture;
import java.util.List;
import java.util.stream.Collectors;

public class AllOfResults {
    
    public static void main(String[] args) {
        List<CompletableFuture<String>> futures = List.of(
            CompletableFuture.supplyAsync(() -> "Result 1"),
            CompletableFuture.supplyAsync(() -> "Result 2"),
            CompletableFuture.supplyAsync(() -> "Result 3")
        );
        
        //allOf возвращает Void — результаты не доступны
        CompletableFuture<Void> all = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
        all.join(); // ждем завершения, но результатов нет
        
        //Собираем результаты вручную через thenApply
        CompletableFuture<List<String>> combined = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .collect(Collectors.toList()));
        
        List<String> results = combined.join();
        System.out.println(results); // [Result 1, Result 2, Result 3]
        
        // ✅ Альтернатива: использование thenAccept для побочного эффекта
        CompletableFuture<Void> log = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenAccept(v -> futures.forEach(f -> System.out.println(f.join())));
        log.join();
        
        //Сборка с преобразованием типов
        CompletableFuture<Integer> totalLength = CompletableFuture
            .allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .mapToInt(String::length)
                .sum());
        System.out.println("Total length: " + totalLength.join());
    }
}

import java.util.concurrent.CompletableFuture;

public class Task020726 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> f1 = CompletableFuture.completedFuture(42);
        CompletableFuture<String> f2 = CompletableFuture.completedFuture("hello");
        CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2);
        System.out.println(all.get());
    }
}

[Источник: файл на диске]
  -> [Page Cache ОС]
    -> [FileInputStream: syscall read()]
      -> [Нативный буфер userspace]
        -> [JNI: копирование в byte[] или напрямую в буфер JVM]
          -> [Варианты обработки:]
            -> [Способ 1: read() посимвольно -> write(int)]
            -> [Способ 2: read(byte[]) -> write(byte[])]
            -> [Способ 3: BufferedInputStream.read() -> BufferedOutputStream.write()]
          -> [FileOutputStream: syscall write()]
            -> [Нативный буфер userspace]
              -> [Page Cache: dirty pages]
                -> [Назначение: файл на диске]

// Функциональный интерфейс для единообразия
@FunctionalInterface
public interface FileCopyStrategy {
    void copy(InputStream source, OutputStream destination) throws IOException;
}

public class FileTypeDetector {
    // Сигнатуры: первые байты файла
    private static final byte[] PNG_SIGNATURE = {(byte) 0x89, 0x50, 0x4E, 0x47};
    private static final byte[] PDF_SIGNATURE = {0x25, 0x50, 0x44, 0x46};
    private static final byte[] ZIP_SIGNATURE = {0x50, 0x4B, 0x03, 0x04};
    
    public FileType detect(InputStream in) throws IOException {
        // PushbackInputStream позволяет вернуть прочитанные байты обратно в поток
        PushbackInputStream pis = new PushbackInputStream(in, 16);
        byte[] header = new byte[16];
        int read = pis.read(header);
        pis.unread(header, 0, read); // Возврат байт в поток
        
        // Определение типа по сигнатуре
        if (matches(header, PNG_SIGNATURE)) return FileType.PNG;
        if (matches(header, PDF_SIGNATURE)) return FileType.PDF;
        if (matches(header, ZIP_SIGNATURE)) return FileType.ZIP;
        return FileType.UNKNOWN;
    }
}

public class FileCopyUtil {
    
    // Копирование одного файла с замером времени
    public CopyResult copySingleFile(Path source, Path destination, 
                                     FileCopyStrategy strategy);
    
    // Копирование нескольких файлов в директорию
    public List<CopyResult> copyDirectory(Path sourceDir, Path targetDir,
                                          FileCopyStrategy strategy);
    
    // Копирование с определением типа
    public TypedCopyResult copyWithTypeDetection(Path source, Path destination);
}

public record CopyResult(
    Path source,
    Path destination,
    long bytesCopied,
    long durationMillis,
    FileCopyStrategy strategy
) {}

[sourceDir: директория]
  -> [Files.list() / DirectoryStream: поток путей]
    -> [Фильтрация: только обычные файлы]
      -> [Для каждого файла:]
        -> [Создание targetPath: targetDir.resolve(sourceDir.relativize(file))]
          -> [Создание родительских директорий: Files.createDirectories()]
            -> [Копирование файла через выбранную стратегию]
              -> [Замер времени: System.nanoTime()]

[FileInputStream.read()] // syscall на каждый байт
  -> [int в стеке]
    -> [FileOutputStream.write(int)] // syscall на каждый байт

[FileInputStream.read(byte[8192])] // syscall на блок
  -> [byte[8192] в heap]
    -> [FileOutputStream.write(byte[8192], 0, len)] // syscall на блок

[BufferedInputStream.read()] // Без syscall, если данные в buf
  -> [buf[8192] внутри BufferedInputStream]
    -> [BufferedOutputStream.write(int)] // Накопление в buf
      -> [При заполнении buf: syscall через underlying FileOutputStream]

// try-with-resources для всех потоков
public void copyWithResources(Path source, Path destination) throws IOException {
    try (InputStream fis = new FileInputStream(source.toFile());
         InputStream bis = new BufferedInputStream(fis); // опционально
         OutputStream fos = new FileOutputStream(destination.toFile());
         OutputStream bos = new BufferedOutputStream(fos)) { // опционально
        
        // Копирование
    }
    // Все потоки закрыты в обратном порядке: bos, fos, bis, fis
}

src/
├── strategy/
│   ├── FileCopyStrategy.java
│   ├── ByteByByteCopy.java
│   ├── BufferedArrayCopy.java
│   └── BufferedStreamCopy.java
├── detector/
│   ├── FileType.java
│   └── FileTypeDetector.java
├── util/
│   ├── FileCopyUtil.java
│   └── CopyResult.java
└── Main.java

import java.util.stream.Stream;

public class Task030726 {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.forEach(System.out::print);
        stream.forEach(System.out::print);
    }
}

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