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

public class FloatLoopProblem {
    
    //Антипаттерн: бесконечный цикл
    public static void badLoop() {
        int iterations = 0;
        for (double d = 0.0; d != 1.0; d += 0.1) {
            iterations++;
            System.out.printf("Итерация %d: %.20f%n", iterations, d);
            if (iterations > 20) break; // защита от вечности
        }
        // Реальный вывод: d проходит через 0.0, 0.1, 0.2, ..., 0.9, 1.0000000000000002, ...
        // Никогда не равно 1.0
    }
    
    //Ошибка с float
    public static void badFloatLoop() {
        for (float f = 0.0f; f != 1.0f; f += 0.1f) {
            // Тоже бесконечный
        }
    }
    
    //Решение 1: целочисленный счетчик
    public static void goodLoopWithCounter() {
        for (int i = 0; i <= 10; i++) {
            double d = i * 0.1; // Вычисляем на каждой итерации
            System.out.println("d = " + d);
        }
    }
    
    //Решение 2: сравнение с эпсилон (допуском)
    public static void goodLoopWithEpsilon() {
        double d = 0.0;
        final double EPSILON = 1e-10;
        while (Math.abs(d - 1.0) > EPSILON) {
            System.out.println("d = " + d);
            d += 0.1;
        }
        System.out.println("Достигнуто: " + d);
    }
    
    //Решение 3: фиксированное количество итераций
    public static void goodFixedIterations() {
        int steps = 10;
        for (int step = 0; step <= steps; step++) {
            double ratio = (double) step / steps; // От 0.0 до 1.0
            System.out.println(ratio);
        }
    }
    
    // Демонстрация погрешности
    public static void demonstratePrecision() {
        double sum = 0.0;
        for (int i = 0; i < 10; i++) {
            sum += 0.1;
        }
        System.out.println("Сумма десяти 0.1: " + sum);           // 0.9999999999999999
        System.out.println("Сравнение с 1.0: " + (sum == 1.0)); // false
    }
    
    public static void main(String[] args) {
        demonstratePrecision();
        goodLoopWithCounter();
    }
}

public class Task170426 {
    public static void main(String[] args) {
        double sum = 0;
        for (double d = 0.0; d != 1.0; d += 0.1) {
            sum += d;
        }
        System.out.println(sum);
    }
}