Memory usage in Java

Memory usage in Java

know how much memory you need

                        <p>Memory usage is well-defined for Java on your computer that every value requires precisely the same amount of memory each time that you run your program. But Java is implemented on a very wide range of computational devices, and memory consumption is implementation-dependent. So, following is some <em>typical</em> values that subject to machine dependencies.</p>

<p>One of Java’s most significant features it its memory allocation system, which is supposed to relieve you from having to worry about memory. Certainly, you’re well-advised to take advantage of this feature when appropriate. Still, it is your responsibility to know, at least approximately, when a program’s memory requirements will prevent you from solving a given problem.</p>

<p>Typical Java implementations use 4 bytes (32 bits) to represent <code class="language-plaintext highlighter-rouge">int</code> values, representing each <code class="language-plaintext highlighter-rouge">char</code> value with 2 bytes (16 bits), each <code class="language-plaintext highlighter-rouge">double</code> and each <code class="language-plaintext highlighter-rouge">long</code> value with 8 bytes (64 bits), and each <code class="language-plaintext highlighter-rouge">boolean</code> value with 1 byte (since computers typically access memory one byte at a time). Combined with knowledge of the amount of memory available, you can calculate limitations from these values. For example, if you have 1GB of memory on your computer (1 billion bytes), you cannot fit more than about 32 million <code class="language-plaintext highlighter-rouge">int</code> values or 16 million <code class="language-plaintext highlighter-rouge">double</code> values in memory at any one time.</p>

<table class="table table-bordered table-hover table-striped">
  <thead>
    <tr>
      <th>type</th>
      <th>Bytes</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">boolean</code></td>
      <td>1</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">byte</code></td>
      <td>1</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">char</code></td>
      <td>2</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">int</code></td>
      <td>4</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">float</code></td>
      <td>4</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">long</code></td>
      <td>8</td>
    </tr>
    <tr>
      <td><code class="language-plaintext highlighter-rouge">double</code></td>
      <td>8</td>
    </tr>
  </tbody>
</table>
<p><em>typical memory requirements for primitive types in Java</em></p>

<p>On the other hand, analyzing memory usage is subject to various differences in machine hardware and in Java implementations, so you should consider the specific examples that we give as indicative of how you might go about determining memory usage when warranted, not the final word for your computer. For example, many data structures involve representation of machine addresses, and the amount of memory needed for a machine address varies from machine to machine. For consistency, the following context assume that 8 bytes are needed to represent addresses, as is typical for 64-bit architectures that are now widely used, recognizing that many older machines use a 32-bit architecture that would involve just 4 bytes per machine address.</p>

<h2 id="objects">Objects</h2>

<p>To determine the memory usage of an object, we add the amount of memory used by each instance variable to the overhead associated with each object, typically 16 bytes. The overhead includes <strong>a reference to the object’s class</strong>, <strong>garbage collection information</strong>, and <strong>synchronization information</strong>. Moreover, the memory usage is typically padded to be a multiple of 8 bytes (machine words, on a 64-bit machine). For example, an <code class="language-plaintext highlighter-rouge">Integer</code> object uses 24 bytes (16 bytes of overhead, 4 bytes for its <code class="language-plaintext highlighter-rouge">int</code> instance variable, and 4 bytes of padding). Similarly, a <code class="language-plaintext highlighter-rouge">Date</code> object (defined in <code class="language-plaintext highlighter-rouge">algs4.jar</code>) also uses 32 bytes: 16 bytes of overhead, 4 bytes for each of its three <code class="language-plaintext highlighter-rouge">int</code> instance variables, and 4 bytes of padding. A reference to an object typically is a memory address and thus uses 8 bytes of memory. For example, a <code class="language-plaintext highlighter-rouge">Counter</code> object (as shown in following figure) uses 32 bytes: 16 bytes of overhead, 8 types for its <code class="language-plaintext highlighter-rouge">String</code> instance variable (a reference), 4 bytes for its <code class="language-plaintext highlighter-rouge">int</code> instance variable, and 4 bytes of padding. When we account for the memory for a reference, we account separately for the memory for the object itself, so this total does not count the memory for the <code class="language-plaintext highlighter-rouge">String</code> value.</p>

<p><img src="/assets/img/placeholder.svg" alt="typical object memory requirements" data-src="https://cdn.frankindev.com/frankindev/image/upload/f_auto,dpr_auto,w_auto/v1604565702/indev.j/typical-object-memory-requirements_zuz7lg.png"></p>

<h2 id="linked-lists">Linked lists</h2>

<p>A nested non-static (inner) class such as the <code class="language-plaintext highlighter-rouge">Node</code> class requires an extra 8 bytes of overhead (for a reference to the enclosing instance). Thus, a <code class="language-plaintext highlighter-rouge">Node</code> object uses 40 bytes (16 bytes of object overhead, 8 bytes each for the references to the <code class="language-plaintext highlighter-rouge">Item</code> and <code class="language-plaintext highlighter-rouge">Node</code> objects, and 8 bytes for the extra overhead). Thus, since an <code class="language-plaintext highlighter-rouge">Integer</code> object uses 24 bytes, a stack with <em>N</em> integers built with a linked-list representation uses <code class="language-plaintext highlighter-rouge">32 + 64N</code> bytes, the usual 16 for object overhead for <code class="language-plaintext highlighter-rouge">Stack</code>, 8 for its reference instance variable, 4 for its <code class="language-plaintext highlighter-rouge">int</code> instance variable, 4 for padding, and 64 for each entry, 40 for a <code class="language-plaintext highlighter-rouge">Node</code> and 24 for an <code class="language-plaintext highlighter-rouge">Integer</code>.</p>

<p><img src="/assets/img/placeholder.svg" alt="example of a inner class memory usage" data-src="https://cdn.frankindev.com/frankindev/image/upload/f_auto,dpr_auto,w_auto/v1604566268/indev.j/inner-class-memory-requirements_jvigmg.png"></p>

<h2 id="arrays">Arrays</h2>

<p>Arrays in Java are implemented as objects, typically with extra overhead for the length.</p>

<p>An <em>array of primitive-type values</em> typically requires 24 bytes of header information (16 bytes of object overhead, 4 bytes for the length, and 4 bytes of padding) plus the memory needed to store the values. For example, an array of <em>N</em> <code class="language-plaintext highlighter-rouge">int</code> values uses <code class="language-plaintext highlighter-rouge">24 + 4N</code> bytes (rounded up to be a multiple of 8), and an array of <em>N</em> <code class="language-plaintext highlighter-rouge">double</code> values uses <code class="language-plaintext highlighter-rouge">24 + 8N</code> bytes.</p>

<p><img src="/assets/img/placeholder.svg" alt="memory usage of int and double array" data-src="https://cdn.frankindev.com/frankindev/image/upload/f_auto,dpr_auto,w_auto/v1604567614/indev.j/array-of-int-double_ary2eu.png"></p>

<p>An <em>array of objects</em> is an array of references to the objects, so we need to add the space for the references to the space required for the objects. For example, an array of <em>N</em> <code class="language-plaintext highlighter-rouge">Date</code> objects uses 24 bytes (array overhead) plus 8<em>N</em> bytes (references) plus 32 bytes for each object and 4 bytes of padding, for a grand total of <code class="language-plaintext highlighter-rouge">24 + 40N</code> bytes. A <em>two-dimensional array</em> is an array of arrays (each array is an object). For example, a two-dimensional <em>M</em>-by-<em>N</em> array of <code class="language-plaintext highlighter-rouge">double</code> values uses 24 bytes (overhead for the array of arrays) plus 8<em>M</em> bytes (references to the row arrays) plus <em>M</em> times 16 bytes (overhead from the row arrays) plus <em>M</em> times <em>N</em> times 8 bytes (for the <em>N</em> <code class="language-plaintext highlighter-rouge">double</code> values in each of the <em>M</em> rows), for a grand total of <code class="language-plaintext highlighter-rouge">8NM + 32M + 24 ~ 8NM</code> bytes. When array entries are objects, a similar accounting leads to a total of <code class="language-plaintext highlighter-rouge">8NM + 32M + 24 ~ 8NM</code> bytes for the array of arrays filled with references to objects, plus the memory for the objects themselves.</p>

<p><img src="/assets/img/placeholder.svg" alt="memory usage of object array" data-src="https://cdn.frankindev.com/frankindev/image/upload/f_auto,dpr_auto,w_auto/v1604567790/indev.j/array-of-objects_qn1rgv.png"></p>

<h2 id="string-objects">String objects</h2>

<p>We account for memory in Java’s <code class="language-plaintext highlighter-rouge">String</code> objects in the same way as for any other object, except that aliasing is common for strings. The standard <code class="language-plaintext highlighter-rouge">String</code> implementation has four instance variables: a reference to a character array (8 bytes) and three <code class="language-plaintext highlighter-rouge">int</code> values (4 bytes each). The first <code class="language-plaintext highlighter-rouge">int</code> value is an offset into the character array; the second is a count (the string length); the third is a hash code that saves recomputation in certain circumstances that need not concern us now. Therefore, each <code class="language-plaintext highlighter-rouge">String</code> object uses a total of 40 bytes (16 bytes for object overhead plus 4 bytes of padding). This space requirement is in addition to the space needed for the characters themselves, which are in the array. The space needed for the characters is accounted for separately because the <code class="language-plaintext highlighter-rouge">char</code> array if often shared among strings. Since <code class="language-plaintext highlighter-rouge">String</code> objects are immutable, this arrangement allows the implementation to save memory when <code class="language-plaintext highlighter-rouge">String</code> objects have the same underlying <code class="language-plaintext highlighter-rouge">value[]</code>.</p>

<p><img src="/assets/img/placeholder.svg" alt="memory usage for string object" data-src="https://cdn.frankindev.com/frankindev/image/upload/f_auto,dpr_auto,w_auto/v1604568584/indev.j/string-object-memory_xiwmki.png"></p>

<h2 id="string-values-and-substrings">String values and substrings</h2>

<p>A <code class="language-plaintext highlighter-rouge">String</code> of length <em>N</em> typically uses 40 bytes (for the <code class="language-plaintext highlighter-rouge">String</code> object) plus 24 + 2<em>N</em> bytes (for the array that contains the characters) for a total of 64 + 2<em>N</em> bytes. But it is typical in string processing to work with substrings, and Java’s representation is meant to allow us to do so without having to make copies of the string’s characters. When you use the <code class="language-plaintext highlighter-rouge">substring()</code> method, you create a new <code class="language-plaintext highlighter-rouge">String</code> object (40 bytes) but reuse string takes just 40 bytes. The character array containing the original string is aliased in the object for the substring; the offset and length fields identify the substring. In other words, a <em>substring takes constant extra memory and forming a substring takes constant time</em>, even when the lengths of the string and the substring are huge. A naive representation that requires copying characters to make substrings would take linear time and space. The ability to create a substring using space (and time) independent of its length is the key to efficiency in many basic string-processing algorithms.</p>

<p>These basic mechanisms are effective for estimating memory usage of a great many programs, but there are numerous complicating factors that can make the task significantly more difficult. We have already noted the potential effect of aliasing. Moreover, memory consumption is a complicated dynamic process when function calls are involved because the system memory allocation mechanism plays a more important role, with more system dependencies. For example, when your program calls a method, the system allocates the memory needed for the method (for its local variables) from a special area of memory called <code class="language-plaintext highlighter-rouge">stack</code> (a system pushdown stack), and when the method returns to the caller, the memory is returned to the stack. For this reason, creating arrays of other large objects in recursive programs is dangerous, since each recursive call implies significant memory usage. When you create an object with <code class="language-plaintext highlighter-rouge">new</code>, the system allocates the memory needed for the object from another special area of memory known as the <code class="language-plaintext highlighter-rouge">heap</code>, and you must remember that every object lives until no references to it remain, at which point a system process known as <em>garbage collection</em> reclaims its memory for the heap. Such dynamics can make the task of precisely estimating memory usage of a program challenging.</p>

                        
Ads by Google

林宏

Frank Lin

Hey, there! This is Frank Lin (@flinhong), one of the 1.4 billion 🇨🇳. This 'inDev. Journal' site holds the exploration of my quirky thoughts and random adventures through life. Hope you enjoy reading and perusing my posts.

YOU MAY ALSO LIKE

Using Liquid in Jekyll - Live with Demos

Web Notes

2016.08.20

Using Liquid in Jekyll - Live with Demos

Liquid is a simple templating language that Jekyll uses to process pages on your site. With Liquid you can output an modify variables, have logic statements inside your pages and loop over content.

Practising closures in JavaScript

JavaScript Notes

2018.12.17

Practising closures in JavaScript

JavaScript is a very function-oriented language. As we know, functions are first class objects and can be easily assigned to variables, passed as arguments, returned from another function invocation, or stored into data structures. A function can access variable outside of it. But what happens when an outer variable changes? Does a function get the most recent value or the one that existed when the function was created? Also, what happens when a function invoked in another place - does it get access to the outer variables of the new place?

Setup an IKEv2 server with StrongSwan

Tutorials

2020.01.09

Setup an IKEv2 server with StrongSwan

IKEv2, or Internet Key Exchange v2, is a protocol that allows for direct IPSec tunneling between two points. In IKEv2 implementations, IPSec provides encryption for the network traffic. IKEv2 is natively supported on some platforms (OS X 10.11+, iOS 9.1+, and Windows 10) with no additional applications necessary, and it handles client hiccups quite smoothly.