public class ThreadLocalLeak {
    
    //Антипаттерн: ThreadLocal без очистки
    private static final ThreadLocal<UserContext> CURRENT_USER = new ThreadLocal<>();
    
    public static void processRequestBad(User user) {
        CURRENT_USER.set(new UserContext(user)); // Установили
        // ... обработка запроса
        // Забыли remove() — данные останутся в потоке навсегда
    }
    
    //Решение: try-finally с remove()
    public static void processRequestGood(User user) {
        try {
            CURRENT_USER.set(new UserContext(user));
            // ... обработка запроса
        } finally {
            CURRENT_USER.remove(); // Гарантированная очистка
        }
    }
    
    // Демонстрация утечки
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // Плохой вариант
        for (int i = 0; i < 10; i++) {
            final int requestId = i;
            executor.submit(() -> {
                processRequestBad(new User("User" + requestId));
            });
        }
        
        Thread.sleep(1000);
        
        // Теперь в потоках пула остались старые данные
        executor.submit(() -> {
            UserContext context = CURRENT_USER.get(); // Может вернуть данные от старого запроса!
            System.out.println("Остались данные: " + context);
        });
        
        executor.shutdown();
    }
    
    // Для веб-фильтра (Spring-стиль)
    public static class WebFilter {
        public void doFilter(Request request, FilterChain chain) {
            try {
                // Установка контекста из запроса
                UserContext.setCurrent(request.getUser());
                chain.proceed();
            } finally {
                UserContext.clear(); // Обязательная очистка после каждого запроса
            }
        }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Task130426 {
    static class UserContext130426 {
        String userId;
        UserContext130426(String userId) { this.userId = userId; }
    }

    static ThreadLocal<UserContext130426> currentUser = new ThreadLocal<>();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        
        executor.submit(() -> {
            currentUser.set(new UserContext130426("user1"));
            System.out.print(currentUser.get().userId + " ");
        });
        
        executor.submit(() -> {
            UserContext130426 ctx = currentUser.get();
            System.out.println(ctx == null ? "null" : ctx.userId);
        });

        executor.shutdown();
    }
}

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