Lab Java Core

public class HelloJava {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Cách dùng: java HelloJava <tên>");
            return;
        }
        System.out.printf("Xin chào %s! Java %s%n",
                args[0], System.getProperty("java.version"));
    }
}

javac -Xlint:all HelloJava.java
java HelloJava Lan

Dùng record, compact constructor, Math.addExact và normalize currency bằng Locale.ROOT.

import java.util.Locale;
import java.util.Objects;

public record Money(long amount, String currency) {
    public Money {
        if (amount < 0) throw new IllegalArgumentException("amount phải >= 0");
        currency = Objects.requireNonNull(currency, "currency")
                .trim().toUpperCase(Locale.ROOT);
        if (currency.length() != 3) throw new IllegalArgumentException("currency phải có 3 ký tự");
    }

    public Money add(Money other) {
        Objects.requireNonNull(other, "other");
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Không thể cộng khác currency");
        }
        return new Money(Math.addExact(amount, other.amount), currency);
    }

    public static void main(String[] args) {
        System.out.println(new Money(10_000, "vnd").add(new Money(5_000, "VND")));
    }
}

import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class WordFrequency {
    public static void main(String[] args) {
        String text = String.join(" ", args);
        Map<String, Long> counts = Arrays.stream(text.toLowerCase(Locale.ROOT).split("[^\\p{L}\\p{N}]+"))
                .filter(word -> !word.isBlank())
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        counts.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue(Comparator.reverseOrder())
                        .thenComparing(Map.Entry.comparingByKey()))
                .limit(10)
                .forEach(entry -> System.out.printf("%-20s %d%n", entry.getKey(), entry.getValue()));
    }
}

Mỗi account có id, balance và ReentrantLock. Khi transfer, lock account có id nhỏ trước. Kiểm tra balance và cập nhật cả hai account trong cùng critical section; unlock theo thứ tự ngược trong finally.

static boolean transfer(Account from, Account to, long amount) {
    Account first = from.id() < to.id() ? from : to;
    Account second = first == from ? to : from;
    first.lock().lock();
    second.lock().lock();
    try {
        if (from.balance() < amount) return false;
        from.withdraw(amount);
        to.deposit(amount);
        return true;
    } finally {
        second.lock().unlock();
        first.lock().unlock();
    }
}

Đây chỉ là phần critical section; bạn phải tự viết Account, workload, executor shutdown và assertion tổng tiền.

try (var executor = Executors.newFixedThreadPool(8)) {
    var profile = CompletableFuture.supplyAsync(() -> loadProfile(userId), executor);
    var orders = CompletableFuture.supplyAsync(() -> loadOrders(userId), executor)
            .exceptionally(cause -> List.of());
    var recommendations = CompletableFuture
            .supplyAsync(() -> loadRecommendations(userId), executor)
            .completeOnTimeout(List.of(), 300, TimeUnit.MILLISECONDS);

    return profile.thenCombine(orders, UserView::withOrders)
            .thenCombine(recommendations, UserView::withRecommendations)
            .orTimeout(800, TimeUnit.MILLISECONDS)
            .join();
}

Hãy tự định nghĩa domain type và test nhánh timeout/failure. Trong ứng dụng thật, cân nhắc propagation cancellation đến I/O client.

var bulkhead = new Semaphore(50);
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    var tasks = IntStream.range(0, 10_000)
            .mapToObj(index -> executor.submit(() -> {
                bulkhead.acquire();
                try {
                    Thread.sleep(Duration.ofMillis(100));
                    return index;
                } finally {
                    bulkhead.release();
                }
            })).toList();
    for (var task : tasks) task.get();
}

Production code phải xử lý interruption, deadline, observability và rejection/cancellation semantics rõ ràng.

formatter.api       exports api.Formatter
formatter.json      requires formatter.api; provides api.Formatter with json.JsonFormatter
formatter.app       requires formatter.api; uses api.Formatter