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