public void simpleTryFinally() {
    try {
        processData();
    } finally {
        cleanup();
    }
}

public String readFile(String path) throws IOException {
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader(path));
        return reader.readLine();
    } finally {
        if (reader != null) {
            reader.close();
        }
    }
}

public void copyFile(String sourcePath, String destPath) throws IOException {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        fis = new FileInputStream(sourcePath);
        try {
            fos = new FileOutputStream(destPath);
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } finally {
            if (fos != null) {
                fos.close();
            }
        }
    } finally {
        if (fis != null) {
            fis.close();
        }
    }
}

public int problematicMethod() {
    try {
        throw new RuntimeException("Critical error");
    } finally {
        return 42;  // Исключение будет подавлено!
    }
}

public int confusingMethod() {
    int result = 0;
    try {
        result = 10;
        return result;
    } finally {
        result = 20;  // Это изменение проигнорируется!
    }
}

public int anotherConfusingMethod() {
    try {
        return 10;
    } finally {
        return 20;  // Теперь вернет 20
    }
}

public void readAndProcess(String path) throws IOException {
    BufferedReader reader = null;
    try {
        reader = new BufferedReader(new FileReader(path));
        process(reader);
    } finally {
        if (reader != null) {
            reader.close();  // Если здесь IOException, исходное исключение потеряно
        }
    }
}

public void readAndProcessSafe(String path) throws IOException {
    BufferedReader reader = null;
    IOException originalException = null;
    try {
        reader = new BufferedReader(new FileReader(path));
        process(reader);
    } catch (IOException e) {
        originalException = e;
        throw e;
    } finally {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException closeException) {
                if (originalException != null) {
                    originalException.addSuppressed(closeException);
                } else {
                    throw closeException;
                }
            }
        }
    }
}

public class ResourceHolder {
    private static final Connection connection;
    
    static {
        Connection temp = null;
        try {
            temp = createConnection();
            initializeSchema(temp);
        } finally {
            if (temp != null) {
                try {
                    temp.close();
                } catch (SQLException e) {
                    // Логирование, но исключение не пробрасывается
                    // Иначе класс станет непригодным к использованию
                    logger.error("Failed to close connection during initialization", e);
                }
            }
        }
        connection = temp;  // Этот код никогда не выполнится, если finally выбросит исключение
    }
}

public class Task140426 {
    public static void main(String[] args) {
        System.out.println(test());
    }

    static int test() {
        try {
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {
            return 3;
        }
    }
}

public class StringLockExample {
    
    //Антипаттерн: синхронизация по строковой константе
    private static final String LOCK = "LOCK"; // Попадает в пул строк
    
    public void badMethod() {
        synchronized (LOCK) { // Опасно! Другие модули могут использовать LOCK
            // критическая секция
        }
    }
    
    //Еще хуже: синхронизация по литералу
    public void evenWorse() {
        synchronized ("LOCK") { // Каждый раз один и тот же объект из пула
            // Эта блокировка глобальна для всей JVM
        }
    }
    
    //Решение 1: выделенный объект для блокировки
    private final Object lock = new Object(); // Уникальный объект
    
    public void goodMethod() {
        synchronized (lock) {
            // Только этот класс использует эту блокировку
        }
    }
    
    //Решение 2: блокировка по имени с уникальными объектами
    private final ConcurrentHashMap<String, ReentrantLock> lockMap = new ConcurrentHashMap<>();
    
    public void lockByName(String resourceId) {
        ReentrantLock lock = lockMap.computeIfAbsent(resourceId, k -> new ReentrantLock());
        lock.lock();
        try {
            // работа с ресурсом resourceId
        } finally {
            lock.unlock();
        }
    }
    
    //Решение 3: использование ReentrantLock с выделенным объектом
    private final ReentrantLock reentrantLock = new ReentrantLock();
    
    public void withReentrantLock() {
        reentrantLock.lock();
        try {
        } finally {
            reentrantLock.unlock();
        }
    }
    
    // Демонстрация проблемы
    public static void main(String[] args) {
        // Модуль A
        Thread t1 = new Thread(() -> {
            synchronized ("SHARED") {
                System.out.println("Модуль A захватил блокировку");
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
            }
        });
        
        // Модуль B (совершенно другой класс, другая команда)
        Thread t2 = new Thread(() -> {
            synchronized ("SHARED") { // Та же строка из пула!
                System.out.println("Модуль B захватил блокировку");
            }
        });
        
        t1.start();
        t2.start(); // Будет ждать, пока t1 не отпустит блокировку
        // Два несвязанных модуля блокируют друг друга!
    }
}

public class Task150426 {
    private static final String LOCK = "LOCK";

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (LOCK) {
                System.out.print("A");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                System.out.print("B");
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized ("LOCK") {
                System.out.print("C");
                System.out.print("D");
            }
        });

        t1.start();
        t2.start();
    }
}

void close() throws Exception;

static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

// Псевдокод, демонстрирующий трансформацию компилятором
BufferedReader br = new BufferedReader(new FileReader(path));
Throwable primaryException = null;
try {
    return br.readLine();
} catch (Throwable t) {
    primaryException = t;
    throw t;
} finally {
    if (br != null) {
        if (primaryException != null) {
            try {
                br.close();
            } catch (Throwable suppressed) {
                primaryException.addSuppressed(suppressed);
            }
        } else {
            br.close();
        }
    }
}

public class ExceptionalResource implements AutoCloseable {
    public void process() {
        throw new IllegalArgumentException("Error in process()");
    }
    
    @Override
    public void close() {
        throw new NullPointerException("Error in close()");
    }
}

public static void demoSuppressedException() throws Exception {
    try (ExceptionalResource resource = new ExceptionalResource()) {
        resource.process();
    }
}

try {
    demoSuppressedException();
} catch (Exception e) {
    assert e instanceof IllegalArgumentException;
    assert e.getMessage().equals("Error in process()");
    assert e.getSuppressed().length == 1;
    assert e.getSuppressed()[0] instanceof NullPointerException;
}

public void copyFile(String sourcePath, String destPath) throws IOException {
    try (FileInputStream fis = new FileInputStream(sourcePath);
         FileOutputStream fos = new FileOutputStream(destPath)) {
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, bytesRead);
        }
    }
}

try (Resource r1 = new Resource(); 
     Resource r2 = new Resource()) {
    throw new PrimaryException();
}
// Если r1.close() и r2.close() оба выбрасывают исключения,
// PrimaryException будет иметь два suppressed исключения

try (Resource resource = new Resource()) {
    resource.process();
} catch (ProcessingException e) {
    // Выполняется после закрытия resource
    logger.error("Processing failed", e);
    // Доступны suppressed исключения из resource.close()
    for (Throwable suppressed : e.getSuppressed()) {
        logger.warn("Suppressed during close", suppressed);
    }
} finally {
    // Выполняется после catch, ресурсы уже закрыты
    metrics.incrementOperationCounter();
}

public class DatabaseConnectionPool implements AutoCloseable {
    private final List<Connection> availableConnections;
    private final List<Connection> inUseConnections;
    private boolean closed = false;
    
    public DatabaseConnectionPool(int size) {
        this.availableConnections = new ArrayList<>(size);
        this.inUseConnections = new ArrayList<>();
        // Инициализация пула
    }
    
    public Connection acquireConnection() {
        ensureOpen();
        // Логика выдачи соединения
    }
    
    public void releaseConnection(Connection conn) {
        ensureOpen();
        // Логика возврата соединения
    }
    
    @Override
    public void close() {
        if (closed) {
            return; // Идемпотентность рекомендуется
        }
        closed = true;
        
        // Закрытие всех соединений
        for (Connection conn : availableConnections) {
            silentlyClose(conn);
        }
        for (Connection conn : inUseConnections) {
            silentlyClose(conn);
        }
    }
    
    private void ensureOpen() {
        if (closed) {
            throw new IllegalStateException("Pool is closed");
        }
    }
    
    private void silentlyClose(Connection conn) {
        try {
            conn.close();
        } catch (SQLException e) {
            // Логирование, но не выброс — не блокируем закрытие остальных
            logger.warn("Failed to close connection", e);
        }
    }
}

public void processBatch(List<String> queries) {
    try (DatabaseConnectionPool pool = new DatabaseConnectionPool(10)) {
        for (String query : queries) {
            Connection conn = pool.acquireConnection();
            try {
                executeQuery(conn, query);
            } finally {
                pool.releaseConnection(conn);
            }
        }
    } // pool автоматически закрывается, все соединения освобождаются
}

public class Task160426 {
    static class CloseableCounter160426 implements AutoCloseable {
        private String id;
        public CloseableCounter160426(String id) { this.id = id; }
        public void close() throws Exception {
            System.out.print(id);
            throw new RuntimeException("close error: " + id);
        }
    }

    public static void main(String[] args) {
        try (CloseableCounter160426 c1 = new CloseableCounter160426("A");
             CloseableCounter160426 c2 = new CloseableCounter160426("B")) {
            throw new RuntimeException("body error");
        } catch (Exception e) {
            System.out.print(e.getMessage());
            for (Throwable suppressed : e.getSuppressed()) {
                System.out.print(suppressed.getMessage());
            }
        }
    }
}