// read() возвращает int, но данные прошли путь: диск -> page cache -> нативный буфер -> heap
int byteValue = fileInputStream.read();

// BufferedInputStream внутренне содержит byte[] buf размером по умолчанию 8192 байт
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.bin"))) {
    int b;
    while ((b = bis.read()) != -1) {
        processByte(b);
    }
}

// Маленький буфер: частые системные вызовы, но быстрое освобождение GC
byte[] smallBuffer = new byte[1024];

// Большой буфер: редкие системные вызовы, но большое выделение памяти
byte[] largeBuffer = new byte[1024 * 1024]; // 1MB

// Переиспользование буфера вместо создания нового при каждой операции
private static final ThreadLocal<byte[]> BUFFER = ThreadLocal.withInitial(() -> new byte[8192]);

public void processFile(String path) throws IOException {
    byte[] buffer = BUFFER.get(); // Переиспользование, не создание
    
    try (InputStream in = new FileInputStream(path)) {
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            processChunk(buffer, bytesRead);
        }
    }
    // Буфер остается в ThreadLocal, не подлежит GC между вызовами
}

// Антипаттерн: чтение байта за байтом без буферизации
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);
    }
}