// Антипаттерн: чтение байта за байтом без буферизации
public void readByteByByte(InputStream in) throws IOException {
    int byteValue;
    while ((byteValue = in.read()) != -1) {
        processByte(byteValue);
    }
}

// Паттерн: буферизованное чтение с обработкой частичного заполнения
public void readBuffered(InputStream in) throws IOException {
    byte[] buffer = new byte[8192]; // 8KB — типичный размер страницы ОС
    int bytesRead;
    
    while ((bytesRead = in.read(buffer)) != -1) {
        processBuffer(buffer, bytesRead);
    }
}

// Пример: flush перед ожиданием ответа
public void sendRequest(OutputStream out, byte[] request) throws IOException {
    out.write(request);
    out.flush(); // Гарантирует, что запрос отправлен до чтения ответа
    
    // Теперь можно читать ответ, не рискуя deadlock из-за буферизации
}

// Цепочка оберток: буферизация + типизированное чтение + сжатие
try (InputStream fis = new FileInputStream("data.bin");
     BufferedInputStream bis = new BufferedInputStream(fis, 8192);
     DataInputStream dis = new DataInputStream(bis);
     GZIPInputStream gzis = new GZIPInputStream(dis)) {
    
    int magicNumber = dis.readInt();      // Чтение 4-байтового int
    long timestamp = dis.readLong();      // Чтение 8-байтового long
    double value = dis.readDouble();      // Чтение 8-байтового double
    String label = dis.readUTF();         // Чтение строки в модифицированном UTF-8
}

public void copyBinaryFile(String sourcePath, String destPath) throws IOException {
    // Буфер 8KB — оптимальный размер для большинства файловых систем
    byte[] buffer = new byte[8192];
    
    try (InputStream in = new FileInputStream(sourcePath);
         OutputStream out = new FileOutputStream(destPath)) {
        
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }
        
        out.flush(); // Явный flush перед закрытием
    }
}

import java.io.*;

public class Task010626 {
    public static void main(String[] args) throws IOException {
        byte[] data = {10, 20, 30, 40, 50};
        InputStream is = new BufferedInputStream(new ByteArrayInputStream(data), 2);
        is.mark(1);
        is.read();
        is.read();
        is.reset();
        System.out.println(is.read());
    }
}

public class VolatileNotAtomic {
    
    //Антипаттерн: volatile без атомарности
    private static volatile int volatileCounter = 0;
    
    //Решение: AtomicInteger
    private static final AtomicInteger atomicCounter = new AtomicInteger(0);
    
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // Неправильный счетчик
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> volatileCounter++);
        }
        
        // Правильный счетчик
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> atomicCounter.incrementAndGet());
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
        
        System.out.println("volatile count: " + volatileCounter);   // почти всегда < 1000
        System.out.println("Atomic count:   " + atomicCounter.get()); // всегда 1000
        
        // Другие методы AtomicInteger
        AtomicInteger ai = new AtomicInteger(0);
        int old = ai.getAndSet(10);        // old = 0, new = 10
        int updated = ai.incrementAndGet(); // 11
        boolean set = ai.compareAndSet(11, 20); // true, меняет 11 на 20
        
        // Для long: AtomicLong
        // Для boolean: AtomicBoolean
        // Для ссылок: AtomicReference<V>
    }
}

public class Task020626 {
    private static volatile int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter++;
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter++;
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(counter);
    }
}

// Конструктор по строковому пути
public FileInputStream(String name) throws FileNotFoundException

// Конструктор по объекту File
public FileInputStream(File file) throws FileNotFoundException

public byte[] readFileContent(String path) {
    try (FileInputStream fis = new FileInputStream(path)) {
        return fis.readAllBytes();
    } catch (FileNotFoundException e) {
        // Файл не существует или недоступен — бизнес-решение
        logger.warn("File not found: {}", path);
        return new byte[0];
    } catch (IOException e) {
        // Другие I/O ошибки при чтении
        logger.error("Failed to read file: {}", path, e);
        throw new RuntimeException("File read error", e);
    }
}

// read() вызывает нативный метод, который выполняет системный вызов
public native int read() throws IOException;

// Путь данных для read():
// 1. Диск -> page cache (ядро)
// 2. page cache -> нативный буфер (userspace, вне heap)
// 3. нативный буфер -> byte[] в heap JVM
// 4. Java-код читает byte[0]

public void readByteByByte(String path) throws IOException {
    try (FileInputStream fis = new FileInputStream(path)) {
        int byteValue;
        // Каждая итерация: системный вызов + копирование в heap для 1 байта
        while ((byteValue = fis.read()) != -1) {
            System.out.printf("%02X ", byteValue);
        }
    }
}

public void readBuffered(String path) throws IOException {
    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path))) {
        int byteValue;
        // Первый read(): чтение 8192 байт в buf[8192] одним системным вызовом
        // Последующие read(): возврат из buf без системных вызовов
        while ((byteValue = bis.read()) != -1) {
            System.out.printf("%02X ", byteValue);
        }
    }
}

try (FileInputStream fis = new FileInputStream(path)) {
    // fis — ссылка в стеке, объект FileInputStream в heap
    // fis.fd — объект FileDescriptor в heap, хранит int fd (файловый дескриптор ОС)
    // При использовании BufferedInputStream: bis.buf — byte[] в heap
}
// После выхода из try:
// 1. Вызывается fis.close() — закрывается файловый дескриптор ОС
// 2. Ссылка fis выходит из области видимости
// 3. Объект FileInputStream становится недостижимым
// 4. GC может собрать объект и связанные FileDescriptor при следующей сборке

// Антипаттерн: утечка файлового дескриптора
FileInputStream fis = new FileInputStream(path);
// Если здесь возникнет исключение, close() не вызовется
fis.read();
fis.close();

// Упрощенная логика из OpenJDK
private final Cleanable cleanable;
private final FileCleanable cleanup;

public FileInputStream(File file) throws FileNotFoundException {
    // ...
    this.fd = new FileDescriptor();
    this.cleanup = new FileCleanable(this.fd);
    this.cleanable = Cleaner.create().register(this, cleanup);
}

import java.io.*;

public class Task030626 {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("missing.txt")) {
            System.out.println("Opened");
        } catch (IOException e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}