public void quickSort(int[] array, int left, int right) {
    logger.trace("Entering quickSort(left={}, right={})", left, right);
    
    if (left < right) {
        int pivot = partition(array, left, right);
        logger.trace("Pivot index={}, array state={}", pivot, Arrays.toString(array));
        
        quickSort(array, left, pivot - 1);
        quickSort(array, pivot + 1, right);
    }
    
    logger.trace("Exiting quickSort(left={}, right={})", left, right);
}

public User authenticate(String username, String passwordHash) {
    logger.debug("Authentication attempt for user={}", username);
    
    User user = userRepository.findByUsername(username);
    logger.debug("User lookup result: found={}, status={}", 
        user != null, user != null ? user.getStatus() : "N/A");
    
    if (user == null || !user.getPasswordHash().equals(passwordHash)) {
        logger.debug("Authentication failed for user={}: invalid credentials", username);
        return null;
    }
    
    if (user.getStatus() == UserStatus.LOCKED) {
        logger.debug("Authentication failed for user={}: account locked", username);
        return null;
    }
    
    logger.debug("Authentication successful for user={}, roles={}", 
        username, user.getRoles());
    return user;
}

@Service
public class OrderProcessingService {
    
    @EventListener
    public void onApplicationReady(ApplicationReadyEvent event) {
        logger.info("Order processing service started, version={}, profile={}",
            buildProperties.getVersion(), 
            Arrays.toString(environment.getActiveProfiles()));
    }
    
    public Order processOrder(OrderRequest request) {
        logger.info("Processing orderId={}, customerId={}, amount={}", 
            request.getOrderId(), request.getCustomerId(), request.getAmount());
        
        Order order = executeBusinessLogic(request);
        
        logger.info("Order {} processed successfully, status={}, durationMs={}", 
            order.getId(), order.getStatus(), order.getProcessingDuration());
        return order;
    }
}

public void sendNotification(User user, Notification notification) {
    try {
        notificationGateway.send(user.getEmail(), notification);
        logger.info("Notification sent to user={}", user.getId());
    } catch (GatewayTimeoutException e) {
        logger.warn("Notification gateway timeout for user={}, will retry asynchronously", 
            user.getId());
        enqueueForRetry(user, notification);
    }
}

public void chargePayment(Payment payment) {
    try {
        paymentGateway.charge(payment);
        logger.info("Payment {} charged successfully", payment.getId());
    } catch (PaymentGatewayException e) {
        if (e.isRetryable()) {
            logger.warn("Payment {} failed with retryable error, scheduling retry", 
                payment.getId());
            scheduleRetry(payment);
        } else {
            logger.error("Payment {} failed with non-retryable error: {}", 
                payment.getId(), e.getMessage(), e);
            markAsFailed(payment);
        }
    }
}

// Псевдокод конфигурации Logback
Logger root = LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
root.setLevel(Level.INFO);

Logger servicePackage = LoggerFactory.getLogger("com.example.service");
servicePackage.setLevel(Level.DEBUG);

Logger orderService = LoggerFactory.getLogger("com.example.service.OrderService");
// orderService не имеет явного уровня, наследует DEBUG от com.example.service

<!-- Logback: отключение additivity для изоляции вывода -->
<logger name="com.example.audit" level="INFO" additivity="false">
    <appender-ref ref="AUDIT_FILE"/>
</logger>

// Правильно: ленивое вычисление через параметризацию
logger.debug("Processing batch of {} items, estimated memory={}MB", 
    batchSize, estimatedMemory);

// Избыточно: guard-метод не нужен для простых параметров
if (logger.isDebugEnabled()) {
    logger.debug("Simple message");
}

// Оправдано: guard для дорогостоящих операций
if (logger.isDebugEnabled()) {
    logger.debug("Complex state: {}", serializeFullObjectGraph(state));
}

import java.util.*;

public class Task140526 {
    public static void main(String[] args) {
        List<Integer> list = List.of(1, 2, 3, 4, 5);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

public class DateFormatSafety {

    //Антипаттерн: общий SimpleDateFormat
    private static final SimpleDateFormat BAD_FORMAT = 
        new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static String badFormat(Date date) {
        return BAD_FORMAT.format(date); // Гонка! Сломанные данные
    }

    //Решение 1: DateTimeFormatter (Java 8+)
    private static final DateTimeFormatter FORMATTER = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static String goodFormat(LocalDateTime dt) {
        return dt.format(FORMATTER); // Потокобезопасно
    }

    public static LocalDateTime goodParse(String str) {
        return LocalDateTime.parse(str, FORMATTER);
    }

    //Решение 2: ThreadLocal для SimpleDateFormat (Java 7 и legacy)
    private static final ThreadLocal<SimpleDateFormat> THREAD_LOCAL = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    public static String threadLocalFormat(Date date) {
        return THREAD_LOCAL.get().format(date);
    }

    // Демонстрация проблемы
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        
        // Плохой вариант – через несколько итераций выбросит исключение
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                try {
                    BAD_FORMAT.parse("2024-01-01 12:00:00");
                } catch (Exception e) {
                    System.err.println("SimpleDateFormat упал: " + e);
                }
            });
        }
        
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS);
        
        // Хороший вариант – никогда не падает
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime now = LocalDateTime.now();
        System.out.println("Форматирование: " + now.format(dtf));
    }
}

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

public class Task150526 {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
        Runnable task = () -> {
            try {
                latch.await();
                for (int i = 0; i < 1000; i++) {
                    String formatted = sdf.format(new Date());
                    sdf.parse(formatted);
                }
            } catch (Exception e) {
                System.out.println("Ошибка в " + Thread.currentThread().getName() + ": " + e);
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();

        Thread.sleep(100);
        latch.countDown();
        latch.countDown();

        t1.join();
        t2.join();
    }
}