Class.forName() bộ nhớ đệm

Question

Trong một trong những ứng dụng của tôi, tôi đang sử dụng như sau:

public void calculate (String className) 
{ 
    ... 
    Class clazz = Class.forName(className); 
    ... 
} 

Chức năng này được gọi là nhiều lần/giây. Có khoảng 10 tên lớp có thể. Và trong khi tôi nhận ra có một số bộ nhớ đệm nội bộ bên trong chức năng này, Tôi nghĩ rằng bộ nhớ đệm này chỉ có sẵn ở cấp bản địa.

Vì lý do này, tôi bắt đầu tự hỏi liệu tôi có nên thêm bộ nhớ đệm của riêng mình hay không.

private static Map<String,Class> classMap; 

public void calculate (String className) 
{ 
    ... 
    Class clazz = classMap.get(className); 
    if (clazz == null) 
    { 
     clazz = Class.forName(className); 
     if (classMap == null) classMap = new HashMap<String, Class>(40); 
     classMap.put(className, clazz); 
    } 
    ... 
} 

Đây có phải là lợi ích hiệu suất hay không thực sự tạo nên sự khác biệt?

Cảm ơn bạn trước

Answer 1

Tôi đã viết một kịch bản nhỏ để tính toán thời gian thực hiện của cả hai chức năng.

Đây là lớp Chính mà tôi đã sử dụng.

public class Benchmark 
{ 
    public static void main(String... pArgs) 
    { 
    // prepare all data as much as possible. 
    // we don't want to do this while the clock is running. 
    Class[] classes = {Object.class, Integer.class, String.class, Short.class, Long.class, Double.class, 
         Float.class, Boolean.class, Character.class, Byte.class}; 
    int cycles = 1000000; 
    String[] classNames = new String[cycles]; 
    for (int i = 0; i < cycles; i++) 
    { 
     classNames[i] = classes[i % classes.length].getName(); 
    } 

    // THERE ARE 2 IMPLEMENTATIONS - CLASSIC vs CACHING 
    Implementation impl = new Caching(); // or Classic(); 

    // Start the clocks ! 
    long startTime = System.currentTimeMillis(); 
    for (int i = 0; i < cycles; i++) 
    { 
     impl.doStuff(classNames[i]); 
    } 
    long endTime = System.currentTimeMillis(); 

    // calculate and display result 
    long totalTime = endTime - startTime; 
    System.out.println(totalTime); 
    } 
} 

Đây là việc thực hiện cổ điển sử dụng Class.forName

private interface Implementation 
    { 
    Class doStuff(String clzName); 
    } 

    private static class Classic implements Implementation 
    { 
    @Override 
    public Class doStuff(String clzName) 
    { 
     try 
     { 
     return Class.forName(clzName); 
     } 
     catch (Exception e) 
     { 
     return null; 
     } 
    } 
    } 

Đây là việc thực hiện thứ hai sử dụng một HashMap để cache Class đối tượng.

private static class Caching implements Implementation 
    { 
    private Map<String, Class> cache = new HashMap<String, Class>(); 

    @Override 
    public Class doStuff(String clzName) 
    { 
     Class clz = cache.get(clzName); 
     if (clz != null) return clz; 
     try 
     { 
     clz = Class.forName(clzName); 
     cache.put(clzName, clz); 
     } 
     catch (Exception e) 
     { 
     } 
     return clz; 
    } 
    } 

Kết quả:

• 1100 ms mà không cần bộ nhớ đệm.
• chỉ 15 mili giây với bộ nhớ đệm.

Kết luận:

• Có một sự khác biệt đáng kể -> có!
• Ứng dụng của tôi có quan trọng không - không hề.

Answer 2

Đây sẽ là một hiệu suất đạt được hay nó thực sự làm cho có sự khác biệt?

Tôi sẽ ngạc nhiên nếu nó tạo ra sự khác biệt đáng kể - và nếu bạn chỉ gọi nó là "vài lần mỗi giây" (thay vì, một triệu) thì thực sự không đáng để tối ưu hóa.

Bạn nên ít nhất thử cách ly này trong tiêu chuẩn trước khi cam kết thiết kế phức tạp hơn này. Tôi thực sự mong đợi Class.forName sẽ được lưu vào bộ nhớ cache này và việc thêm độ phức tạp hơn vào ứng dụng của bạn sẽ không tốt.

Answer 3

Không, bạn không nên. Class.forName sẽ không tải cùng một lớp hai lần nhưng sẽ cố gắng tìm lớp trong số các lớp được nạp. Nó được thực hiện ở cấp độ bản địa và được cho là rất hiệu quả.

Answer 4

Class.forName() thực hiện hai điều:

1. rồi nó lấy một lớp được nạp từ classloader
2. nếu không có lớp học như vậy được tìm thấy, nó sẽ cố gắng để tải nó.

Phần # 1 khá nhanh. # 2 là nơi mà công việc thực sự bắt đầu (nơi JVM có thể nhấn vào đĩa cứng hoặc thậm chí mạng, tùy thuộc vào trình nạp lớp). Và nếu bạn chuyển các tham số tương tự vào, thì tất cả, nhưng các lời gọi đầu tiên sẽ không bao giờ đến bướC# 2.

Vì vậy, không: đó là có thể là không đáng tối ưu hóa.