Trong Java, cách tốt nhất để xác định kích thước của một đối tượng là gì?

Tôi có một ứng dụng đọc tệp CSV với hàng đống dữ liệu. Tôi cung cấp cho người dùng một bản tóm tắt về số lượng hàng dựa trên các loại dữ liệu, nhưng tôi muốn đảm bảo rằng tôi không đọc quá nhiều hàng dữ liệu và gây ra OutOfMemoryErrors. Mỗi hàng dịch thành một đối tượng. Có một cách dễ dàng để tìm ra kích thước của đối tượng đó theo chương trình? Có một tài liệu tham khảo xác định mức độ lớn của các kiểu nguyên thủy và tham chiếu đối tượng cho a VMkhông?

Ngay bây giờ, tôi có mã cho biết đọc tới 32.000 hàng , nhưng tôi cũng muốn có mã cho biết đọc càng nhiều hàng càng tốt cho đến khi tôi sử dụng 32 MB bộ nhớ. Có lẽ đó là một câu hỏi khác, nhưng tôi vẫn muốn biết.

Bạn có thể sử dụng gói java.lang.instrument

Biên dịch và đặt lớp này trong JAR:

import java.lang.instrument.Instrumentation;

public class ObjectSizeFetcher {
    private static Instrumentation instrumentation;

    public static void premain(String args, Instrumentation inst) {
        instrumentation = inst;
    }

    public static long getObjectSize(Object o) {
        return instrumentation.getObjectSize(o);
    }
}

Thêm phần sau vào MANIFEST.MF:

Premain-Class: ObjectSizeFetcher

Sử dụng getObjectSize:

public class C {
    private int x;
    private int y;

    public static void main(String [] args) {
        System.out.println(ObjectSizeFetcher.getObjectSize(new C()));
    }
}

Gọi với:

java -javaagent:ObjectSizeFetcherAgent.jar C

Bạn nên sử dụng jol , một công cụ được phát triển như một phần của dự án OpenJDK.

JOL (Bố cục đối tượng Java) là hộp công cụ nhỏ để phân tích các sơ đồ bố trí đối tượng trong các JVM. Các công cụ này đang sử dụng rất nhiều Unsafe, JVMTI và Servicilityility Agent (SA) để giải mã bố cục, dấu chân và tham chiếu đối tượng thực tế. Điều này làm cho JOL chính xác hơn nhiều so với các công cụ khác dựa trên các đống, các giả định đặc tả, v.v.

Để có được kích thước của các nguyên hàm, tham chiếu và các phần tử mảng, sử dụng VMSupport.vmDetails(). Trên Oracle JDK 1.8.0_40 chạy trên Windows 64 bit (được sử dụng cho tất cả các ví dụ sau), phương thức này trả về

Running 64-bit HotSpot VM.
Using compressed oop with 0-bit shift.
Using compressed klass with 3-bit shift.
Objects are 8 bytes aligned.
Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]

Bạn có thể lấy kích thước nông của một đối tượng bằng cách sử dụng ClassLayout.parseClass(Foo.class).toPrintable()(tùy ý chuyển một thể hiện đến toPrintable). Đây chỉ là không gian được sử dụng bởi một thể hiện duy nhất của lớp đó; nó không bao gồm bất kỳ đối tượng nào khác được tham chiếu bởi lớp đó. Nó không bao gồm VM overhead cho tiêu đề đối tượng, liên kết trường và padding. Dành cho java.util.regex.Pattern:

java.util.regex.Pattern object internals:
 OFFSET  SIZE        TYPE DESCRIPTION                    VALUE
      0     4             (object header)                01 00 00 00 (0000 0001 0000 0000 0000 0000 0000 0000)
      4     4             (object header)                00 00 00 00 (0000 0000 0000 0000 0000 0000 0000 0000)
      8     4             (object header)                cb cf 00 20 (1100 1011 1100 1111 0000 0000 0010 0000)
     12     4         int Pattern.flags                  0
     16     4         int Pattern.capturingGroupCount    1
     20     4         int Pattern.localCount             0
     24     4         int Pattern.cursor                 48
     28     4         int Pattern.patternLength          0
     32     1     boolean Pattern.compiled               true
     33     1     boolean Pattern.hasSupplementary       false
     34     2             (alignment/padding gap)        N/A
     36     4      String Pattern.pattern                (object)
     40     4      String Pattern.normalizedPattern      (object)
     44     4        Node Pattern.root                   (object)
     48     4        Node Pattern.matchRoot              (object)
     52     4       int[] Pattern.buffer                 null
     56     4         Map Pattern.namedGroups            null
     60     4 GroupHead[] Pattern.groupNodes             null
     64     4       int[] Pattern.temp                   null
     68     4             (loss due to the next object alignment)
Instance size: 72 bytes (reported by Instrumentation API)
Space losses: 2 bytes internal + 4 bytes external = 6 bytes total

Bạn có thể có được một cái nhìn tóm tắt về kích thước sâu của một đối tượng sử dụng GraphLayout.parseInstance(obj).toFootprint(). Tất nhiên, một số đối tượng trong dấu chân có thể được chia sẻ (cũng được tham chiếu từ các đối tượng khác), do đó, đó là sự ước tính quá mức của không gian có thể được thu hồi khi đối tượng đó được thu gom rác. Đối với kết quả của Pattern.compile("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$")(lấy từ câu trả lời này ), jol báo cáo tổng số dấu chân là 1840 byte, trong đó chỉ có 72 là bản thể Mẫu.

java.util.regex.Pattern instance footprint:
     COUNT       AVG       SUM   DESCRIPTION
         1       112       112   [C
         3       272       816   [Z
         1        24        24   java.lang.String
         1        72        72   java.util.regex.Pattern
         9        24       216   java.util.regex.Pattern$1
        13        24       312   java.util.regex.Pattern$5
         1        16        16   java.util.regex.Pattern$Begin
         3        24        72   java.util.regex.Pattern$BitClass
         3        32        96   java.util.regex.Pattern$Curly
         1        24        24   java.util.regex.Pattern$Dollar
         1        16        16   java.util.regex.Pattern$LastNode
         1        16        16   java.util.regex.Pattern$Node
         2        24        48   java.util.regex.Pattern$Single
        40                1840   (total)

Thay vào đó GraphLayout.parseInstance(obj).toPrintable(), nếu bạn sử dụng , jol sẽ cho bạn biết địa chỉ, kích thước, loại, giá trị và đường dẫn của các cuộc hội thảo trường đến từng đối tượng được tham chiếu, mặc dù điều đó thường quá nhiều chi tiết không hữu ích. Đối với ví dụ mẫu đang diễn ra, bạn có thể nhận được những điều sau đây. (Địa chỉ có thể sẽ thay đổi giữa các lần chạy.)

java.util.regex.Pattern object externals:
          ADDRESS       SIZE TYPE                             PATH                           VALUE
         d5e5f290         16 java.util.regex.Pattern$Node     .root.next.atom.next           (object)
         d5e5f2a0        120 (something else)                 (somewhere else)               (something else)
         d5e5f318         16 java.util.regex.Pattern$LastNode .root.next.next.next.next.next.next.next (object)
         d5e5f328      21664 (something else)                 (somewhere else)               (something else)
         d5e647c8         24 java.lang.String                 .pattern                       (object)
         d5e647e0        112 [C                               .pattern.value                 [^, [, a, -, z, A, -, Z, 0, -, 9, _, ., +, -, ], +, @, [, a, -, z, A, -, Z, 0, -, 9, -, ], +, \, ., [, a, -, z, A, -, Z, 0, -, 9, -, ., ], +, $]
         d5e64850        448 (something else)                 (somewhere else)               (something else)
         d5e64a10         72 java.util.regex.Pattern                                         (object)
         d5e64a58        416 (something else)                 (somewhere else)               (something else)
         d5e64bf8         16 java.util.regex.Pattern$Begin    .root                          (object)
         d5e64c08         24 java.util.regex.Pattern$BitClass .root.next.atom.val$rhs        (object)
         d5e64c20        272 [Z                               .root.next.atom.val$rhs.bits   [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e64d30         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64d48         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e64d60         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64d78         24 java.util.regex.Pattern$1        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e64d90         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e64da8         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e64dc0         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs.val$lhs (object)
         d5e64dd8         24 java.util.regex.Pattern$5        .root.next.atom.val$lhs        (object)
         d5e64df0         24 java.util.regex.Pattern$5        .root.next.atom                (object)
         d5e64e08         32 java.util.regex.Pattern$Curly    .root.next                     (object)
         d5e64e28         24 java.util.regex.Pattern$Single   .root.next.next                (object)
         d5e64e40         24 java.util.regex.Pattern$BitClass .root.next.next.next.atom.val$rhs (object)
         d5e64e58        272 [Z                               .root.next.next.next.atom.val$rhs.bits [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e64f68         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e64f80         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$lhs.val$rhs (object)
         d5e64f98         24 java.util.regex.Pattern$5        .root.next.next.next.atom.val$lhs.val$lhs (object)
         d5e64fb0         24 java.util.regex.Pattern$1        .root.next.next.next.atom.val$lhs.val$rhs (object)
         d5e64fc8         24 java.util.regex.Pattern$5        .root.next.next.next.atom.val$lhs (object)
         d5e64fe0         24 java.util.regex.Pattern$5        .root.next.next.next.atom      (object)
         d5e64ff8         32 java.util.regex.Pattern$Curly    .root.next.next.next           (object)
         d5e65018         24 java.util.regex.Pattern$Single   .root.next.next.next.next      (object)
         d5e65030         24 java.util.regex.Pattern$BitClass .root.next.next.next.next.next.atom.val$rhs (object)
         d5e65048        272 [Z                               .root.next.next.next.next.next.atom.val$rhs.bits [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
         d5e65158         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs.val$lhs (object)
         d5e65170         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs.val$rhs (object)
         d5e65188         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$lhs (object)
         d5e651a0         24 java.util.regex.Pattern$1        .root.next.next.next.next.next.atom.val$lhs.val$lhs.val$rhs (object)
         d5e651b8         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs.val$lhs (object)
         d5e651d0         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom.val$lhs (object)
         d5e651e8         24 java.util.regex.Pattern$5        .root.next.next.next.next.next.atom (object)
         d5e65200         32 java.util.regex.Pattern$Curly    .root.next.next.next.next.next (object)
         d5e65220        120 (something else)                 (somewhere else)               (something else)
         d5e65298         24 java.util.regex.Pattern$Dollar   .root.next.next.next.next.next.next (object)

Các mục "(cái gì khác)" mô tả các đối tượng khác trong heap không phải là một phần của biểu đồ đối tượng này .

Tài liệu jol tốt nhất là các mẫu jol trong kho jol. Các mẫu thể hiện các hoạt động jol phổ biến và chỉ ra cách bạn có thể sử dụng jol để phân tích VM và các phần tử thu gom rác.

Tôi vô tình tìm thấy một lớp java "jdk.nashorn.iternal.ir.debug.ObjectSizeCalculator", đã có trong jdk, rất dễ sử dụng và có vẻ khá hữu ích để xác định kích thước của một đối tượng.

System.out.println(ObjectSizeCalculator.getObjectSize(new gnu.trove.map.hash.TObjectIntHashMap<String>(12000, 0.6f, -1)));
System.out.println(ObjectSizeCalculator.getObjectSize(new HashMap<String, Integer>(100000)));
System.out.println(ObjectSizeCalculator.getObjectSize(3));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[]{1, 2, 3, 4, 5, 6, 7 }));
System.out.println(ObjectSizeCalculator.getObjectSize(new int[100]));

các kết quả:

164192
48
16
48
416

Vài năm trước, Javawworld đã có một bài viết về việc xác định kích thước của các đối tượng Java tổng hợp và có khả năng lồng nhau , về cơ bản họ sẽ thực hiện việc tạo ra một triển khai sizeof () trong Java. Cách tiếp cận về cơ bản dựa trên công việc khác, nơi mọi người xác định bằng thực nghiệm kích thước của các đối tượng nguyên thủy và các đối tượng Java điển hình và sau đó áp dụng kiến ​​thức đó vào một phương pháp đệ quy một biểu đồ đối tượng để kiểm tra tổng kích thước.

Nó luôn luôn có phần kém chính xác hơn so với triển khai C gốc đơn giản chỉ vì những điều xảy ra đằng sau hậu trường của một lớp nhưng nó phải là một chỉ báo tốt.

Ngoài ra, một dự án SourceForge được gọi một cách thích hợp là sizeof cung cấp thư viện Java5 với cách triển khai sizeof ().

PS Không sử dụng phương pháp tuần tự hóa, không có mối tương quan giữa kích thước của một đối tượng được tuần tự hóa và dung lượng bộ nhớ mà nó tiêu thụ khi còn sống.

Thứ nhất "kích thước của một đối tượng" không phải là một khái niệm được xác định rõ trong Java. Bạn có thể có nghĩa là chính đối tượng, chỉ với các thành viên của nó, Đối tượng và tất cả các đối tượng mà nó đề cập đến (biểu đồ tham chiếu). Bạn có thể có nghĩa là kích thước trong bộ nhớ hoặc kích thước trên đĩa. Và JVM được phép tối ưu hóa những thứ như Chuỗi.

Vì vậy, cách duy nhất đúng là hỏi JVM, với một trình lược tả tốt (tôi sử dụng YourKit ), đây có thể không phải là điều bạn muốn.

Tuy nhiên, từ mô tả ở trên, có vẻ như mỗi hàng sẽ được khép kín và không có cây phụ thuộc lớn, vì vậy phương thức tuần tự hóa có thể sẽ là một xấp xỉ tốt trên hầu hết các JVM. Cách dễ nhất để làm điều này là như sau:

 Serializable ser;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(baos);
 oos.writeObject(ser);
 oos.close();
 return baos.size();

Hãy nhớ rằng nếu bạn có các đối tượng với các tham chiếu chung thì điều này sẽ không cho kết quả chính xác và kích thước của tuần tự hóa sẽ không luôn luôn khớp với kích thước trong bộ nhớ, nhưng đó là một xấp xỉ tốt. Mã sẽ hiệu quả hơn một chút nếu bạn khởi tạo kích thước ByteArrayOutputStream thành một giá trị hợp lý.

Nếu bạn muốn biết bao nhiêu bộ nhớ đang được sử dụng trong JVM của bạn và bao nhiêu là miễn phí, bạn có thể thử một cái gì đó như thế này:

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();

chỉnh sửa: Tôi nghĩ rằng điều này có thể hữu ích vì tác giả câu hỏi cũng nói rằng anh ta muốn có logic xử lý "đọc càng nhiều hàng càng tốt cho đến khi tôi sử dụng 32 MB bộ nhớ."

Quay lại khi tôi làm việc tại Twitter, tôi đã viết một tiện ích để tính kích thước đối tượng sâu. Nó tính đến các mô hình bộ nhớ khác nhau (32 bit, oops nén, 64 bit), phần đệm, phần đệm lớp con, hoạt động chính xác trên các cấu trúc dữ liệu tròn và mảng. Bạn chỉ có thể biên dịch tập tin .java này; nó không có phụ thuộc bên ngoài:

https://github.com/twitter/commons/blob/master/src/java/com/twitter/common/objectsize/ObjectSizeCalculator.java

Phần lớn các câu trả lời khác cung cấp kích thước nông - ví dụ: kích thước của HashMap mà không có bất kỳ khóa hoặc giá trị nào, không có khả năng là những gì bạn muốn.

Dự án jamm sử dụng gói java.lang.instrumentation ở trên nhưng đi trên cây và do đó có thể cung cấp cho bạn sử dụng bộ nhớ sâu.

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

Để sử dụng MemoryMeter, hãy khởi động JVM bằng "-javaagent: /jamm.jar"

Bạn phải đi bộ các đối tượng bằng cách sử dụng sự phản chiếu. Hãy cẩn thận khi bạn làm:

• Chỉ cần phân bổ một đối tượng có một số chi phí trong JVM. Số lượng thay đổi theo JVM để bạn có thể biến giá trị này thành tham số. Ít nhất làm cho nó là một hằng số (8 byte?) Và áp dụng cho mọi thứ được phân bổ.
• Về bytelý thuyết chỉ là 1 byte không có nghĩa là nó chỉ mất một bộ nhớ.
• Sẽ có các vòng lặp trong các tham chiếu đối tượng, vì vậy bạn sẽ cần giữ một HashMaphoặc somesuch bằng cách sử dụng các đối tượng bằng như bộ so sánh để loại bỏ các vòng lặp vô hạn.

@jodonnell: Tôi thích sự đơn giản của giải pháp của bạn, nhưng nhiều đối tượng không phải là Tuần tự hóa (vì vậy điều này sẽ tạo ra một ngoại lệ), các trường có thể là nhất thời và các đối tượng có thể ghi đè các phương thức chuẩn.

Bạn phải đo nó bằng một công cụ hoặc ước tính nó bằng tay và nó phụ thuộc vào JVM mà bạn đang sử dụng.

Có một số chi phí cố định cho mỗi đối tượng. Nó đặc trưng cho JVM, nhưng tôi thường ước tính 40 byte. Sau đó, bạn phải nhìn vào các thành viên của lớp. Tham chiếu đối tượng là 4 (8) byte trong JVM 32 bit (64 bit). Các loại nguyên thủy là:

• boolean và byte: 1 byte
• char và ngắn: 2 byte
• int và float: 4 byte
• dài và gấp đôi: 8 byte

Mảng tuân theo các quy tắc tương tự; nghĩa là, đó là một tham chiếu đối tượng để lấy 4 (hoặc 8) byte trong đối tượng của bạn và sau đó độ dài của nó nhân với kích thước của phần tử của nó.

Cố gắng thực hiện theo chương trình với các lệnh gọi để Runtime.freeMemory()không mang lại cho bạn độ chính xác cao, vì các cuộc gọi không đồng bộ đến trình thu gom rác, v.v. Cấu hình heap bằng -Xrunhprof hoặc các công cụ khác sẽ cho bạn kết quả chính xác nhất.

Các java.lang.instrument.Instrumentationlớp học cung cấp một cách tốt đẹp để có được kích thước của một đối tượng Java, nhưng nó đòi hỏi bạn phải xác định một premainvà chạy chương trình của bạn với một đại lý java. Điều này rất nhàm chán khi bạn không cần bất kỳ tác nhân nào và sau đó bạn phải cung cấp một tác nhân Jar giả cho ứng dụng của mình.

Vì vậy, tôi đã có một giải pháp thay thế bằng cách sử dụng Unsafelớp từ sun.misc. Vì vậy, xem xét việc căn chỉnh heap đối tượng theo kiến ​​trúc bộ xử lý và tính toán bù trường tối đa, bạn có thể đo kích thước của Đối tượng Java. Trong ví dụ dưới đây, tôi sử dụng một lớp phụ trợ UtilUnsafeđể có được một tham chiếu đến sun.misc.Unsafeđối tượng.

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS/BYTE;
private static final int MIN_SIZE = 16; 

public static int sizeOf(Class src){
    //
    // Get the instance fields of src class
    // 
    List<Field> instanceFields = new LinkedList<Field>();
    do{
        if(src == Object.class) return MIN_SIZE;
        for (Field f : src.getDeclaredFields()) {
            if((f.getModifiers() & Modifier.STATIC) == 0){
                instanceFields.add(f);
            }
        }
        src = src.getSuperclass();
    }while(instanceFields.isEmpty());
    //
    // Get the field with the maximum offset
    //  
    long maxOffset = 0;
    for (Field f : instanceFields) {
        long offset = UtilUnsafe.UNSAFE.objectFieldOffset(f);
        if(offset > maxOffset) maxOffset = offset; 
    }
    return  (((int)maxOffset/WORD) + 1)*WORD; 
}
class UtilUnsafe {
    public static final sun.misc.Unsafe UNSAFE;

    static {
        Object theUnsafe = null;
        Exception exception = null;
        try {
            Class<?> uc = Class.forName("sun.misc.Unsafe");
            Field f = uc.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            theUnsafe = f.get(uc);
        } catch (Exception e) { exception = e; }
        UNSAFE = (sun.misc.Unsafe) theUnsafe;
        if (UNSAFE == null) throw new Error("Could not obtain access to sun.misc.Unsafe", exception);
    }
    private UtilUnsafe() { }
}

Ngoài ra còn có công cụ Bộ đo Bộ nhớ (trước đây là Google Code , giờ là trên GitHub ), đơn giản và được xuất bản theo giấy phép Apache 2.0 thân thiện với thương mại , như đã thảo luận trong một câu hỏi tương tự .

Nó cũng yêu cầu một đối số dòng lệnh cho trình thông dịch java nếu bạn muốn đo mức tiêu thụ byte bộ nhớ, nhưng nếu không thì dường như chỉ hoạt động tốt, ít nhất là trong các kịch bản tôi đã sử dụng nó.

Không cần phải lộn xộn với thiết bị, v.v. và nếu bạn không cần biết kích thước chính xác byte của một đối tượng, bạn có thể thực hiện theo cách tiếp cận sau:

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

do your job here

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

Bằng cách này, bạn đọc bộ nhớ đã sử dụng trước và sau, và gọi cho GC ngay trước khi nhận được bộ nhớ đã sử dụng, bạn giảm "nhiễu" xuống gần bằng 0.

Để có kết quả đáng tin cậy hơn, bạn có thể chạy công việc của mình n lần, sau đó chia bộ nhớ đã sử dụng cho n, thu được bao nhiêu bộ nhớ mà một lần chạy. Thậm chí nhiều hơn, bạn có thể chạy toàn bộ nhiều lần hơn và kiếm trung bình.

Đây là một tiện ích tôi đã tạo bằng cách sử dụng một số ví dụ được liên kết để xử lý 32 bit, 64 bit và 64 bit với OOP được nén. Nó sử dụng sun.misc.Unsafe.

Nó sử dụng Unsafe.addressSize()để có được kích thước của một con trỏ riêng và Unsafe.arrayIndexScale( Object[].class )cho kích thước của một tham chiếu Java.

Nó sử dụng phần bù trường của một lớp đã biết để tính ra kích thước cơ sở của một đối tượng.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Stack;
import sun.misc.Unsafe;

/** Usage: 
 * MemoryUtil.sizeOf( object )
 * MemoryUtil.deepSizeOf( object )
 * MemoryUtil.ADDRESS_MODE
 */
public class MemoryUtil
{
    private MemoryUtil()
    {
    }

    public static enum AddressMode
    {
        /** Unknown address mode. Size calculations may be unreliable. */
        UNKNOWN,
        /** 32-bit address mode using 32-bit references. */
        MEM_32BIT,
        /** 64-bit address mode using 64-bit references. */
        MEM_64BIT,
        /** 64-bit address mode using 32-bit compressed references. */
        MEM_64BIT_COMPRESSED_OOPS
    }

    /** The detected runtime address mode. */
    public static final AddressMode ADDRESS_MODE;

    private static final Unsafe UNSAFE;

    private static final long ADDRESS_SIZE; // The size in bytes of a native pointer: 4 for 32 bit, 8 for 64 bit
    private static final long REFERENCE_SIZE; // The size of a Java reference: 4 for 32 bit, 4 for 64 bit compressed oops, 8 for 64 bit
    private static final long OBJECT_BASE_SIZE; // The minimum size of an Object: 8 for 32 bit, 12 for 64 bit compressed oops, 16 for 64 bit
    private static final long OBJECT_ALIGNMENT = 8;

    /** Use the offset of a known field to determine the minimum size of an object. */
    private static final Object HELPER_OBJECT = new Object() { byte b; };


    static
    {
        try
        {
            // Use reflection to get a reference to the 'Unsafe' object.
            Field f = Unsafe.class.getDeclaredField( "theUnsafe" );
            f.setAccessible( true );
            UNSAFE = (Unsafe) f.get( null );

            OBJECT_BASE_SIZE = UNSAFE.objectFieldOffset( HELPER_OBJECT.getClass().getDeclaredField( "b" ) );

            ADDRESS_SIZE = UNSAFE.addressSize();
            REFERENCE_SIZE = UNSAFE.arrayIndexScale( Object[].class );

            if( ADDRESS_SIZE == 4 )
            {
                ADDRESS_MODE = AddressMode.MEM_32BIT;
            }
            else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 8 )
            {
                ADDRESS_MODE = AddressMode.MEM_64BIT;
            }
            else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 4 )
            {
                ADDRESS_MODE = AddressMode.MEM_64BIT_COMPRESSED_OOPS;
            }
            else
            {
                ADDRESS_MODE = AddressMode.UNKNOWN;
            }
        }
        catch( Exception e )
        {
            throw new Error( e );
        }
    }


    /** Return the size of the object excluding any referenced objects. */
    public static long shallowSizeOf( final Object object )
    {
        Class<?> objectClass = object.getClass();
        if( objectClass.isArray() )
        {
            // Array size is base offset + length * element size
            long size = UNSAFE.arrayBaseOffset( objectClass )
                    + UNSAFE.arrayIndexScale( objectClass ) * Array.getLength( object );
            return padSize( size );
        }
        else
        {
            // Object size is the largest field offset padded out to 8 bytes
            long size = OBJECT_BASE_SIZE;
            do
            {
                for( Field field : objectClass.getDeclaredFields() )
                {
                    if( (field.getModifiers() & Modifier.STATIC) == 0 )
                    {
                        long offset = UNSAFE.objectFieldOffset( field );
                        if( offset >= size )
                        {
                            size = offset + 1; // Field size is between 1 and PAD_SIZE bytes. Padding will round up to padding size.
                        }
                    }
                }
                objectClass = objectClass.getSuperclass();
            }
            while( objectClass != null );

            return padSize( size );
        }
    }


    private static final long padSize( final long size )
    {
        return (size + (OBJECT_ALIGNMENT - 1)) & ~(OBJECT_ALIGNMENT - 1);
    }


    /** Return the size of the object including any referenced objects. */
    public static long deepSizeOf( final Object object )
    {
        IdentityHashMap<Object,Object> visited = new IdentityHashMap<Object,Object>();
        Stack<Object> stack = new Stack<Object>();
        if( object != null ) stack.push( object );

        long size = 0;
        while( !stack.isEmpty() )
        {
            size += internalSizeOf( stack.pop(), stack, visited );
        }
        return size;
    }


    private static long internalSizeOf( final Object object, final Stack<Object> stack, final IdentityHashMap<Object,Object> visited )
    {
        // Scan for object references and add to stack
        Class<?> c = object.getClass();
        if( c.isArray() && !c.getComponentType().isPrimitive() )
        {
            // Add unseen array elements to stack
            for( int i = Array.getLength( object ) - 1; i >= 0; i-- )
            {
                Object val = Array.get( object, i );
                if( val != null && visited.put( val, val ) == null )
                {
                    stack.add( val );
                }
            }
        }
        else
        {
            // Add unseen object references to the stack
            for( ; c != null; c = c.getSuperclass() )
            {
                for( Field field : c.getDeclaredFields() )
                {
                    if( (field.getModifiers() & Modifier.STATIC) == 0 
                            && !field.getType().isPrimitive() )
                    {
                        field.setAccessible( true );
                        try
                        {
                            Object val = field.get( object );
                            if( val != null && visited.put( val, val ) == null )
                            {
                                stack.add( val );
                            }
                        }
                        catch( IllegalArgumentException e )
                        {
                            throw new RuntimeException( e );
                        }
                        catch( IllegalAccessException e )
                        {
                            throw new RuntimeException( e );
                        }
                    }
                }
            }
        }

        return shallowSizeOf( object );
    }
}

Tôi đang tìm kiếm một tính toán thời gian chạy của một kích thước đối tượng đáp ứng các yêu cầu sau:

• Có sẵn trong thời gian chạy mà không cần bao gồm các thiết bị.
• Hoạt động với Java 9+ mà không cần truy cập vào Không an toàn.
• Chỉ dựa trên Class. Không phải là một sizeOf sâu có tính đến độ dài chuỗi, độ dài mảng, v.v.

Phần sau đây dựa trên mã cốt lõi của bài viết chuyên gia java gốc ( https://www.javaspecialists.eu/archive/Issue078.html ) và một vài bit từ phiên bản Không an toàn trong câu trả lời khác cho câu hỏi này.

Tôi hy vọng ai đó thấy nó hữu ích.

public class JavaSize {

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS / BYTE;
private static final int HEADER_SIZE = 8;

public static int sizeOf(Class<?> clazz) {
    int result = 0;

    while (clazz != null) {
        Field[] fields = clazz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            if (!Modifier.isStatic(fields[i].getModifiers())) {
                if (fields[i].getType().isPrimitive()) {
                    Class<?> primitiveClass = fields[i].getType();
                    if (primitiveClass == boolean.class || primitiveClass == byte.class) {
                        result += 1;
                    } else if (primitiveClass == short.class) {
                        result += 2;
                    } else if (primitiveClass == int.class || primitiveClass == float.class) {
                        result += 4;
                    } else if (primitiveClass == double.class || primitiveClass == long.class) {
                        result += 8;
                    }

                } else {
                    // assume compressed references.
                    result += 4;
                }
            }
        }

        clazz = clazz.getSuperclass();

        // round up to the nearest WORD length.
        if ((result % WORD) != 0) {
            result += WORD - (result % WORD);
        }
    }

    result += HEADER_SIZE;

    return result;
}

}

Không có cuộc gọi phương thức, nếu đó là những gì bạn đang yêu cầu. Với một ít nghiên cứu, tôi cho rằng bạn có thể tự viết. Một thể hiện cụ thể có kích thước cố định xuất phát từ số lượng tài liệu tham khảo và giá trị nguyên thủy cộng với dữ liệu sổ sách cá thể. Bạn chỉ đơn giản là đi bộ đồ thị đối tượng. Các loại hàng càng ít thay đổi, càng dễ dàng.

Nếu điều đó quá chậm hoặc chỉ là rắc rối nhiều hơn giá trị của nó, thì luôn luôn có hàng lỗi thời lỗi thời.

Tôi đã viết một bài kiểm tra nhanh một lần để ước tính khi đang bay:

public class Test1 {

    // non-static nested
    class Nested { }

    // static nested
    static class StaticNested { }

    static long getFreeMemory () {
        // waits for free memory measurement to stabilize
        long init = Runtime.getRuntime().freeMemory(), init2;
        int count = 0;
        do {
            System.out.println("waiting..." + init);
            System.gc();
            try { Thread.sleep(250); } catch (Exception x) { }
            init2 = init;
            init = Runtime.getRuntime().freeMemory();
            if (init == init2) ++ count; else count = 0;
        } while (count < 5);
        System.out.println("ok..." + init);
        return init;
    }

    Test1 () throws InterruptedException {

        Object[] s = new Object[10000];
        Object[] n = new Object[10000];
        Object[] t = new Object[10000];

        long init = getFreeMemory();

        //for (int j = 0; j < 10000; ++ j)
        //    s[j] = new Separate();

        long afters = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            n[j] = new Nested();

        long aftersn = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            t[j] = new StaticNested();

        long aftersnt = getFreeMemory();

        System.out.println("separate:      " + -(afters - init) + " each=" + -(afters - init) / 10000);
        System.out.println("nested:        " + -(aftersn - afters) + " each=" + -(aftersn - afters) / 10000);
        System.out.println("static nested: " + -(aftersnt - aftersn) + " each=" + -(aftersnt - aftersn) / 10000);

    }

    public static void main (String[] args) throws InterruptedException {
        new Test1();
    }

}

Khái niệm chung là phân bổ các đối tượng và đo lường sự thay đổi trong không gian heap miễn phí. Khóa chính getFreeMemory(), yêu cầu GC chạy và chờ kích thước heap miễn phí được báo cáo để ổn định . Đầu ra của ở trên là:

nested:        160000 each=16
static nested: 160000 each=16

Đó là những gì chúng ta mong đợi, đưa ra hành vi căn chỉnh và chi phí tiêu đề khối heap có thể.

Phương pháp thiết bị chi tiết trong câu trả lời được chấp nhận ở đây chính xác nhất. Phương pháp tôi mô tả là chính xác nhưng chỉ trong các điều kiện được kiểm soát trong đó không có luồng nào khác đang tạo / loại bỏ các đối tượng.

Chỉ cần sử dụng java trực quan VM.

Nó có mọi thứ bạn cần để cấu hình và gỡ lỗi các vấn đề bộ nhớ.

Nó cũng có bảng điều khiển OQL (Ngôn ngữ truy vấn đối tượng) cho phép bạn thực hiện nhiều việc hữu ích, một trong số đó là sizeof(o)

Khi sử dụng JetBrains IntelliJ, trước tiên hãy bật "Đính kèm tác nhân bộ nhớ" trong Tệp | Cài đặt | Xây dựng, Thi công, Triển khai | Trình gỡ lỗi.

Khi gỡ lỗi, nhấp chuột phải vào một biến quan tâm và chọn "Tính kích thước giữ lại":

Câu trả lời của tôi dựa trên mã được cung cấp bởi Nick. Mã đó đo tổng số byte được chiếm bởi đối tượng được tuần tự hóa. Vì vậy, điều này thực sự đo các công cụ tuần tự hóa + dấu chân bộ nhớ đối tượng đơn giản (ví dụ chỉ là tuần tự hóa intvà bạn sẽ thấy tổng số byte được tuần tự hóa là không 4). Vì vậy, nếu bạn muốn lấy số byte thô được sử dụng chính xác cho đối tượng của mình - bạn cần sửa đổi mã đó một chút. Thích như vậy:

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectSizeCalculator {
    private Object getFirstObjectReference(Object o) {
        String objectType = o.getClass().getTypeName();

        if (objectType.substring(objectType.length()-2).equals("[]")) {
            try {
                if (objectType.equals("java.lang.Object[]"))
                    return ((Object[])o)[0];
                else if (objectType.equals("int[]"))
                    return ((int[])o)[0];
                else
                    throw new RuntimeException("Not Implemented !");
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        return o;
    } 

    public int getObjectSizeInBytes(Object o) {
        final String STRING_JAVA_TYPE_NAME = "java.lang.String";

        if (o == null)
            return 0;

        String objectType = o.getClass().getTypeName();
        boolean isArray = objectType.substring(objectType.length()-2).equals("[]");

        Object objRef = getFirstObjectReference(o);
        if (objRef != null && !(objRef instanceof Serializable))
            throw new RuntimeException("Object must be serializable for measuring it's memory footprint using this method !");

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
            oos.close();
            byte[] bytes = baos.toByteArray();

            for (int i = bytes.length - 1, j = 0; i != 0; i--, j++) {
                if (objectType != STRING_JAVA_TYPE_NAME) {
                    if (bytes[i] == 112)
                        if (isArray)
                            return j - 4;
                        else
                            return j;
                } else {
                    if (bytes[i] == 0)
                        return j - 1;
                }
            }
        } catch (Exception e) {
            return -1;
        }

        return -1;
    }    

}