public class FinalizeVsCleaner {
    
    //Антипаттерн: finalize (deprecated)
    @Deprecated
    static class BadResource {
        private final FileInputStream stream;
        
        BadResource(String path) throws IOException {
            this.stream = new FileInputStream(path);
        }
        
        @Override
        protected void finalize() throws Throwable {
            stream.close(); // Неизвестно, когда и будет ли вызвано!
        }
    }
    
    //Решение: AutoCloseable + try-with-resources
    static class GoodResource implements AutoCloseable {
        private final FileInputStream stream;
        
        GoodResource(String path) throws IOException {
            this.stream = new FileInputStream(path);
        }
        
        public void doWork() { /* ... */ }
        
        @Override
        public void close() throws IOException {
            if (stream != null) stream.close();
        }
    }
    
    // Cleaner для критических native-ресурсов (Java 9+)
    static class NativeResource implements AutoCloseable {
        private final Cleaner cleaner = Cleaner.create();
        private final Cleaner.Cleanable cleanable;
        private final long nativeHandle;
        
        NativeResource(long handle) {
            this.nativeHandle = handle;
            this.cleanable = cleaner.register(this, new CleanupAction(handle));
        }
        
        private static class CleanupAction implements Runnable {
            private final long handle;
            CleanupAction(long handle) { this.handle = handle; }
            @Override
            public void run() {
                freeNativeMemory(handle); // native-функция
            }
        }
        
        @Override
        public void close() {
            cleanable.clean(); // явный вызов
        }
        
        private static native void freeNativeMemory(long handle);
    }
}

public class Task100626 {
    static class Resource implements AutoCloseable {
        
        @Override
        public void close() {
            throw new RuntimeException("Close exception");
        }
    }

    public static void main(String[] args) {
        
        try (Resource r = new Resource()) {
            
            throw new IllegalArgumentException("Try exception");
            
        } catch (Exception e) {
            
            System.out.println(e.getClass().getSimpleName());
            Throwable[] suppressed = e.getSuppressed();
            
            if (suppressed.length > 0) {
                System.out.println(suppressed[0].getClass().getSimpleName());
            }
        }
    }
}

// Упрощенная структура из OpenJDK
public class BufferedInputStream extends FilterInputStream {
    // Внутренний буфер в heap JVM
    protected volatile byte[] buf;
    
    // Количество байт, фактически доступных в буфере
    protected int count;
    
    // Текущая позиция чтения в буфере
    protected int pos;
    
    // Позиция маркера для mark/reset, -1 если не установлен
    protected int markpos = -1;
    
    // Максимальное количество байт, читаемых после mark
    protected int marklimit;
    
    // Конструкторы
    public BufferedInputStream(InputStream in) {
        this(in, 8192); // Размер по умолчанию
    }
    
    public BufferedInputStream(InputStream in, int size) {
        super(in);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size]; // Выделение в heap
    }
}

// Упрощенная логика fill()
private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    
    if (markpos < 0) {
        // Маркер не установлен — читаем с начала буфера
        pos = 0;
    } else if (pos >= buffer.length) {
        // Позиция достигла конца буфера
        if (markpos > 0) {
            // Сдвигаем данные от markpos к началу
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        } else if (buffer.length >= marklimit) {
            // Буфер превысил лимит маркера — сбрасываем
            markpos = -1;
            pos = 0;
        } else {
            // Расширяем буфер
            int nsz = pos * 2;
            if (nsz > marklimit) nsz = marklimit;
            byte[] nbuf = new byte[nsz];
            System.arraycopy(buffer, 0, nbuf, 0, pos);
            buf = nbuf;
            buffer = nbuf;
            markpos = 0;
        }
    }
    
    count = pos;
    // Системный вызов: чтение из underlying потока
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0) count = n + pos;
}

try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("data.bin"), 8192)) {
    
    int firstByte = bis.read(); // Инициирует fill()
}

[Java: bis.read()]
  -> [BufferedInputStream: pos=0, count=0, буфер пуст]
    -> [fill()]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [JNI: нативный readBytes]
          -> [Ядро ОС: syscall read(fd, native_buf, 8192)]
            -> [Page Cache: поиск/загрузка страниц]
            -> [Копирование: 8192 байт из page cache в native_buf]
          -> [Возврат в userspace]
        -> [JNI: копирование 8192 байт в buf[8192] в heap]
      -> [BufferedInputStream: count=8192, pos=0]
    -> [Возврат buf[0] как int]

int secondByte = bis.read(); // pos=1, count=8192, системный вызов отсутствует
int thirdByte = bis.read();  // pos=2, count=8192, системный вызов отсутствует

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 1 < 8192 — да]
    -> [Возврат buf[1] как int, pos++]

// После 8192 вызовов read()
int byte8193 = bis.read(); // pos=8192, count=8192, буфер пуст

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 8192 < 8192 — нет]
    -> [fill()]
      -> [System.arraycopy при необходимости]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [Новый системный вызов]
      -> [count=новое_значение, pos=0]
    -> [Возврат buf[0]]

public void processFile(String path) throws IOException {
    // buf создается в Eden space при конструировании BufferedInputStream
    try (BufferedInputStream bis = new BufferedInputStream(
            new FileInputStream(path))) {
        
        int b;
        // Цикл без аллокаций в heap — GC не вовлечен
        while ((b = bis.read()) != -1) {
            processByte(b);
        }
        
    } // close() вызывается автоматически
      // buf становится недостижимым
      // GC собирает buf и bis при следующей minor collection
}

// Потенциально проблематично: 1MB буфер
BufferedInputStream bis = new BufferedInputStream(fis, 1024 * 1024);

// Антипаттерн: утечка ссылки
private InputStream leakedStream;

public void open(String path) throws IOException {
    leakedStream = new BufferedInputStream(new FileInputStream(path));
    // Если исключение позже — поток не закрыт, buf не освобожден
}

bis.mark(1024); // Запомнить позицию, лимит 1024 байт вперед
// Чтение до 1024 байт
bis.reset();    // Вернуться к отмеченной позиции

// Из fill(): буфер расширяется до marklimit
byte[] nbuf = new byte[nsz]; // Новый массив в heap
System.arraycopy(buffer, 0, nbuf, 0, pos); // Копирование старых данных
buf = nbuf; // Старая ссылка на массив теряется, GC собирает старый buf

public class BufferedPerformanceDemo {
    
    private static final int FILE_SIZE = 10 * 1024 * 1024; // 10 MB
    
    public static void main(String[] args) throws IOException {
        // Создание тестового файла
        createTestFile("test.bin", FILE_SIZE);
        
        // Тест 1: FileInputStream без буферизации
        measure("FileInputStream raw", () -> {
            try (FileInputStream fis = new FileInputStream("test.bin")) {
                while (fis.read() != -1) {} // Побайтово
            }
        });
        
        // Тест 2: FileInputStream с внешним буфером
        measure("FileInputStream + byte[]", () -> {
            try (FileInputStream fis = new FileInputStream("test.bin")) {
                byte[] buf = new byte[8192];
                while (fis.read(buf) != -1) {}
            }
        });
        
        // Тест 3: BufferedInputStream (внутренняя буферизация)
        measure("BufferedInputStream", () -> {
            try (BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream("test.bin"))) {
                while (bis.read() != -1) {} // Побайтово, но буферизовано
            }
        });
    }
    
    private static void measure(String name, Runnable task) {
        long start = System.nanoTime();
        task.run();
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("%s: %d ms%n", name, ms);
    }
    
    private static void createTestFile(String path, int size) throws IOException {
        byte[] data = new byte[size];
        new Random().nextBytes(data);
        try (FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(data);
        }
    }
}

import java.io.*;

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

public class SystemGcExample {
    
    //Антипаттерн: вызов System.gc()
    public static void badPractice() {
        // ... после обработки больших данных
        System.gc(); // Бесполезно и вредно!
        // JVM может проигнорировать, а если запустит — вызовет паузу
    }
    
    //Решение: довериться JVM
    public static void goodPractice() {
        // Просто работаем, JVM сама решит, когда собрать мусор
        byte[] data = new byte[1024 * 1024];
        // данные становятся недоступными
        data = null;
        // JVM соберет их при необходимости
    }
    
    // Для отладки: мониторинг GC через MXBean
    public static void printGcStats() {
        for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
            System.out.println(bean.getName() + ": " + bean.getCollectionCount() + " collections");
        }
    }
    
    // Единственное разумное использование: сигнал в тестах или бенчмарках
    public static void onlyForBenchmark() {
        // При бенчмаркинге можно вызвать несколько раз для стабилизации состояния
        for (int i = 0; i < 3; i++) {
            System.gc();
            Thread.sleep(100);
        }
    }
    
    public static void main(String[] args) {
        goodPractice();
        System.out.println("GC вызов не гарантирован, не полагайтесь на него");
    }
}

public class Task120626 {
    static boolean finalized = false;

    @Override
    protected void finalize() {
        finalized = true;
    }

    public static void main(String[] args) {
        new Task120626();
        System.gc();
        System.out.println(finalized);
    }
}