String Pool, intern và concatenation

Bổ sung · đã đối chiếu tài liệu

Đọc theo reference và value, không đọc theo tên biến

a và b là hai biến reference; cả hai trỏ tới cùng một String object biểu diễn "java". == kiểm identity, equals kiểm nội dung. Literal vẫn là object kiểu String, không phải một vùng ký tự nằm ngoài hệ thống object. [S1] [S2]

Guarantee: literal cùng nội dung và giá trị String của constant expression được intern. Không suy rộng thành “mọi String bằng nội dung đều cùng object”: dữ liệu đọc từ file, HTTP hoặc được xây lúc chạy không có contract tự động canonicalize chỉ vì nội dung giống literal. [S2] [S3]

Bổ sung · đã đối chiếu tài liệu

Đếm object có điều kiện, không học thuộc “luôn tạo hai”

Bảng giả định các dòng chạy tuần tự và hoàn thành bình thường. Ngay sau dòng tạo c, có hai String identities đang được các biến này giữ: canonical và explicit. Không đồng nhất số identity quan sát được với số lần cấp phát vật lý sau tối ưu JIT, hoặc số backing arrays. API/JLS quy định behavior quan sát được, không bắt người học dự đoán layout nội bộ. [S1] [S10]

Bổ sung · contract chính xác và thí nghiệm có điều kiện

Điểm khó: intern xảy ra trước phép so sánh với literal

Đọc đúng thứ tự của đoạn nguồn: runtime.intern() được gọi trước hai lệnh println. Vì vậy không được kết luận dòng đầu luôn false chỉ vì StringBuilder.toString() đã tạo object mới. Canonicalization có thể chọn chính object mới đó. [S1] [S6]

Ở cả hai nhánh, canonical == "java" là true. Trạng thái pool có thể đã bị ảnh hưởng bởi code khác hoặc việc chuẩn bị literal; đoạn nguồn không tự thiết lập một pool rỗng. Nhánh “chưa có” là giải thích contract, không phải lời hứa lần chạy nào cũng quan sát được. [S1] [S9]

Biến thể có precondition rõ · đặt trong main · đầu ra false rồi true.

String existing = "java"; // Establish canonical identity first.
String built = new StringBuilder().append("ja").append("va").toString();
String canonical = built.intern();

System.out.println(built == existing);     // false
System.out.println(canonical == existing); // true

Trong biến thể này, canonical reference đã tồn tại và còn được giữ trước khi tạo built, nên kết quả là xác định. Bỏ qua giá trị trả về của intern() không tự gán lại biến reference của caller. [S1] [S6]

Bổ sung · đã đối chiếu tài liệu

final không đồng nghĩa compile-time constant

Bài tập bổ sung · ConcatProbe.java · bốn biến thể cần phân biệt.

public class ConcatProbe {
    static String constant() { return "ja" + "va"; }

    static String runtime(String part) { return part + "va"; }

    static String finalConstant() {
        final String part = "ja";
        return part + "va";
    }

    static String finalRuntime(String value) {
        final String part = value;
        return part + "va";
    }

    public static void main(String[] args) {
        System.out.println(constant() == "java");           // true
        System.out.println(runtime("ja") == "java");        // false
        System.out.println(finalConstant() == "java");      // true
        System.out.println(finalRuntime("ja") == "java");   // false
    }
}

Một biến final String lấy giá trị từ parameter hoặc lời gọi method không tự trở thành constant variable. Trái lại, final String part = "ja" thỏa điều kiện để tham gia constant expression. Output của chương trình là true, false, true, false theo đúng thứ tự. [S3] [S4] [S5]

Kiểm bytecode trên đúng JDK đang dùng; lưu phiên bản compiler cùng output.

javac --release 21 ConcatProbe.java
java ConcatProbe
javap -c -v ConcatProbe > concat-bytecode.txt

Expected observations: tìm literal dùng bởi constant()/finalConstant(); trên javac 21 của lần kiểm chứng này, runtime concat đi qua invokedynamic và bootstrap StringConcatFactory.makeConcatWithConstants. Không chép thuộc số index constant pool hoặc coi một bytecode shape là cam kết cho mọi compiler. StringConcatFactory có từ Java 9; tài liệu tham chiếu ở đây là Java 21. [S8] [S13]

Bổ sung · đã đối chiếu tài liệu

Immutable content không biến mọi workflow thành thread-safe

Biến String vẫn có thể được gán một reference khác; object cũ không bị sửa nội dung. Ngược lại, final StringBuilder chỉ không cho gán lại reference, không ngăn append. Khi nhiều threads cùng cập nhật một biến chia sẻ bằng đọc–tính–ghi, cần protocol đồng bộ riêng dù mỗi giá trị String là immutable. [S1] [S5] [S15]

Bổ sung · đã đối chiếu tài liệu

Ba khái niệm cần giữ tách biệt khi nhìn javap và heap

JVMS mô tả run-time constant pool và cách dẫn xuất string constants; tài liệu JDK 7 xác nhận thay đổi allocation của interned Strings khỏi permanent generation sang phần heap chính. Đây là lịch sử implementation HotSpot, không phải một yêu cầu layout mới của JLS. [S9] [S10] [S11]

Quan sát có giới hạn: dùng javap -v để xem metadata; với một JVM thử nghiệm đang chạy, xem jcmd PID help VM.stringtable trước rồi mới dùng jcmd PID VM.stringtable nếu runtime hỗ trợ. Thay PID bằng process ID thực và kiểm quyền truy cập. Hai công cụ cho hai loại bằng chứng khác nhau, không phải hai góc nhìn của cùng một bảng. [S13] [S14]

Bổ sung · lựa chọn API và evidence

Xây chuỗi cục bộ rồi xuất một snapshot

Ví dụ bổ sung · đặt trong main · mutation của builder không đổi String đã trả về.

StringBuilder builder = new StringBuilder();
for (String item : java.util.List.of("java", "core")) {
    if (builder.length() > 0) {
        builder.append(", ");
    }
    builder.append(item);
}
String result = builder.toString();
builder.append("!");
System.out.println(result); // java, core

Output là java, core, không có dấu chấm than. StringBuilder.toString() cung cấp String snapshot độc lập với các lần sửa builder tiếp theo. Đề xuất giữ builder cục bộ trong một lần xây output; cân nhắc capacity khi biết kích thước và có bằng chứng allocation phù hợp. [S6]

StringBuffer đồng bộ các method cần thiết, nhưng chuỗi thao tác “kiểm length rồi append” có thể bị thread khác xen giữa nếu caller không bảo vệ toàn bộ workflow. Đừng coi việc thay tên class từ Builder sang Buffer là phép sửa mọi lỗi concurrency. [S7]

Bổ sung · interview evidence

Giữ 6 mục checklist, kiểm chứng bằng 16 điều kiện

Bài tập bổ sung · StringIdentityCheck.java · cố ý thiết lập canonical reference trước để có kết quả xác định.

public class StringIdentityCheck {
    static int checks;

    static void verify(String name, boolean actual, boolean expected) {
        if (actual != expected) {
            throw new AssertionError(name + ": " + actual);
        }
        checks++;
    }

    public static void main(String[] args) {
        String pooled = "java"; // Establish a live canonical reference first.
        String explicit = new String("java");
        String built = new StringBuilder().append("ja").append("va").toString();
        String part = "ja";
        final String constantPart = "ja";
        final String runtimePart = new String("ja");

        verify("same literal", pooled == "java", true);
        verify("new identity", pooled == explicit, false);
        verify("new equality", pooled.equals(explicit), true);
        verify("builder identity before intern", built == pooled, false);
        verify("intern canonical", built.intern() == pooled, true);
        verify("intern did not reassign", built == pooled, false);
        verify("new then intern", explicit.intern() == pooled, true);
        verify("constant concatenation", ("ja" + "va") == pooled, true);
        verify("runtime concatenation", (part + "va") == pooled, false);
        verify("runtime value equality", (part + "va").equals(pooled), true);
        verify("final constant", (constantPart + "va") == pooled, true);
        verify("final runtime", (runtimePart + "va") == pooled, false);
        verify("hello trap", "hello" == new String("hello").intern(), true);
        verify("ab constant trap", "ab" == ("a" + "b"), true);
        String r = "a";
        verify("ab runtime trap", "ab" == (r + "b"), false);

        StringBuilder builder = new StringBuilder("ja");
        String snapshot = builder.toString();
        builder.append("va");
        verify("snapshot unchanged", snapshot.equals("ja"), true);
        System.out.println("PASS: " + checks + " checks");
    }
}

Chạy độc lập trên JDK 21; chương trình dùng AssertionError trực tiếp nên không cần -ea.

javac --release 21 StringIdentityCheck.java ConcatProbe.java
java StringIdentityCheck
java ConcatProbe

Acceptance: StringIdentityCheck in PASS: 16 checks; ConcatProbe in bốn dòng true, false, true, false. Phần “intern did not reassign” chỉ đúng với precondition canonical đã được giữ trước đó trong bài test; không phủ nhận nhánh pool chưa có ở mục 3.

Artifact tự học: giữ source đã chạy, java -version, stdout, concat-bytecode.txt và câu trả lời cho 6 mục checklist. Chưa có benchmark về memory/throughput trong bài này; không suy ra hiệu năng từ 16 kiểm tra correctness. Các bài kiểm chứng bổ sung không thay đổi tổng lab chính thức của Part 01.