Most Popular Posts


JVM 64-bit OutOfMemory / Compressed references

If you are running on 64-bit OS and JRockit JVM 64-bit has the heap < 4GB in size and you experience OutOfMemory errors, try disabling compressed references by using the following option in your scripts:




where 1/true stands for enabling the option.
You can also use the following format, when using different heap sizes:

-XXcompressedRefs:size=4GB for Xmx <=2g
-XXcompressedRefs:size=32GB for Xmx <=25g
-XXcompressedRefs:size=64GB for Xmx <=57g

What compressed references does, it limits all pointers (to classes, objects, threads) stored on the heap to 32bits, hence less usage of the heap. 


Define Heap Size/ Memory management

Define Heap Size/ Memory management


Xmx sets the maximum size of the heap. Maximum value should be the maximum available, but in such a way that it does not cause any error, or about 75% of the system physical memory (depends on the OS).


Xms sets the minimum & initial size of the heap. Recommended to set the same value as the Xmx to minimize allocation overhead of the heap.

-Xmn, -XXNewSize, -XXMaxNewSize

Xns sets the size of the Young/ Nursery generation heap. This is the place where new objects land in the first place before being promoted to the other space.

XX:NewSize - Use   this option to set the New generation Java heap size. Can be set to be one-fourth the size of the maximum heap size. Increase the value of this option for larger numbers of short-lived objects.

-XX:MaxNewSize - Use this option to set the maximum New generation Java heap size.



Prints the additional information


Configures the memory system for memory-intensive workloads and sets an expectation to enable large amounts of memory resources to ensure high throughput. The JRockit JVM will also use large pages, if available.



Sets the garbage collector to use a concurrent strategy



Sets the garbage collector to use a parallel strategy

Specifies what to prioritize: even pause times or maximum throughput

Specifies a suitable pause time for the application


Define Maximum heap for the Perm Genaration.

(Permanent generation) (non-heap) Stores classes, methods and other meta data

Other settings:

  • -Xss - If the thread stack size (-Xss) has not been set the default value depends on the threading system and the platform you are running on. When using thin threads the minimum thread stack size is 8 kilobytes and the default is 64 kilobytes. When using native threads the minimum thread stack size is 16 kilobytes. For Windows the default thread stack size when using native threads is 64 kilobytes and for Linux it is 128 kilobytes.

  • -XX:SurvivorRatio - The New generation area is divided into several sub-areas: Eden, Survival Space I and Survival Space II. Use the -XX:SurvivorRatio=X option to configure the ratio of the Eden/Survivor Space size. When it is 1:x Eg., -XX:SurvivorRatio=6 - each survivor space will be 1/8 the young generation).

  • –XX:NewRatio=n is used divide heap into old and new generation. If we use. -- XX:NewRatio=5, then you create an old-to-new ratio of 5:1; the old generation occupies 5/6 of the heap while the new generation occupies 1/6 of the heap (-XX:NewRatio=3 - the young generation will occupy 1/4 the overall heap).

Tables were taken from the Oracle website, and changed to suit the blog.

JRockit vs HotSpot JVM Difference

Jrockit was developed by Appeal Virtual Machines and acquired by BEA Systems, and later on acquired by Oracle.
HotSpot is a Java Virtual Machine (JVM) currently hold by Oracle Corporation. 

JRockit is based on the HotSpot JVM by Sun Microsystems, and now Oracle. It has been developed in order to make HotSpot more reliable, and faster to used in server side environment. Jrockit has a slightly bit different heap organisation, garbage collector methods, and optimisations. More information about GC for HotSpot can be found here.

Although JRockit is supposed to have more optimised functions, it is not the rule. Some applications might run faster under HotSpot, and some can be tuned more for JRockit. You don't know it until you try it :)

Additional information:

Garbage Collectors - JRockit

  • Dynamic (default one)
    • Throughput – for maximum throughput (default):  –XgcPrio:throughput
    • Pausetime – for short and even pause times: –XgcPrio:pausetime
    • Deterministic – for very short and deterministic pause times (requires Oracle JRockit Real Time)
  • Static (1x Generational, 2x Concurrent, 1x Parallel)
    • Generational
      • Generational Copy: -Xgc:gencopy
    • Concurrent
      • Single-spaced mostly concurrent: –Xgc:singlecon
      • Generational mostly concurrent: –Xgc:gencon
    • Parallel
      • General parallel: –Xgc:genpar



  • Generational Copy:
    • best to use with small heap and for testing purposes
    • splits heap into generations

  • Generational parallel collector:
    • causes longer pauses/ stop-the-world
    • multiple threads to speed up the process
    • segments the heap into nursery and tenured generations (objects that survive two cycles are promoted from nursery to tenured generation)
    • use when the application has many short lived objects
  • Concurrent:
    • Single-spaced mostly concurrent collector:
      • almost no pauses
      • works concurrently
      • uses entire heap
      • will not pause the application as long as it can collect dead objects
    • Generational mostly concurrent collector:
      • frequent stop-the-world
      • splits the heap -> parallel on nursery, concurrent on tenured generation
      • shorter nursery will cause more objects in tenured, hence more stop-the-world
  • Parallel:
    • Single-spaced parallel collector:
      • causes longer pauses/ stop-the-world
      • multiple threads to speed up the process
      • does not segment heap into multiple generations
      • use when the application has more long lived objects



"The higher the memory throughput the shorter is the time between the two events. Moreover, the higher the memory throughput the smaller the heap you will need."
" The longer the pause, the more unresponsive your system will be. The worst pause time and the average pause time are the two most interesting values you can use for tuning the system."


Garbage Collectors - HotSpot


Types of Garbage Collectors in HotSpot:
  • Serial
  • Parallel
  • Concurrent (CMS)

Young Generation Collectors:
  1. -XX:+UseSerialGC
  2. -XX:+UseParallelGC (Use parallel for Young, Serial for Old)
  3. -XX:+UseParNewGC

Old Generation Collectors:

  1. -XX:+UseParallelOldGC (Parallel Young and Old)
  2. -XX:+UseConcMarkSweepGC –XX:-UseParNewGC (Concurrent Mark Sweep with Serial Young)
  3. -XX:+UseConcMarkSweepGC –XX:+UseParNewG (Concurrent Mark Sweep + Parallel Young)
Additional note:

-XX:+DisableExplicitGC - prevent calls to System.gc()


Serial collector:


Serial Collector - runs in single thread. No communication overhead between the threads. Used for mini data sets (<100MB). This collector is quick but suited for single CPU machines.

Parallel collector:

and (optionally) enable parallel compaction with
This type of collector is similar to the serial collector, but runs with multiple threads and does the minor collection in these threads. Be default:

N garbage collector threads = N CPUs on the host.

We can take the control over the number of threads by using the following option:

-XX:ParallelGCThreads=[number of threads]

Concurrent collector:


One thread is used during initial mark and remark phase. For the concurrent marking and sweeping, CMS thread runs along the application threads. Used when the short pauses and response time are crucial.

In this collector parallel version of the young generation collector is used. For the Old/ Tenured generation, serial collector is used.

Concurrent low pause collector:

-Xincgc ™ or -XX:+UseConcMarkSweepGC

This collector is used to collect Old Generation and is done concurrently with the running application, however application is still paused for short amounts of time during the collection.. A parallel version of the young generation copying collector is used with the concurrent collector. 

Incremental low pause collector:


This is currently not under the development, and has not changed since the J2SE Platform version 1.4.2


ParallelGC partially implies the -XX:+UseConcMarkSweepGC and should not (this doesn't mean you can't use it ;) ) be used in the same cmd line.

Garbage Collection (GC)

Garbage Collection is integral part of the JVM (Java Virtual Machine) and it is used to reclaim memory occupied by the unused objects.

When the application runs, it creates objects. Once the object is created it occupies some memory. When the object is not used/ referenced it can be considered as unused and will remain in the memory until the garbage collector claims the memory occupied by this object.

Objects at first are created and put in the Young Generation space. After some time can be moved (Partial/ Minor Garbage Collection) into the Old Generation space. Once the Young and Old Generation is FULL, Full Garbage Collection is run. 

This operation might impact the flow of the application, as it might take a very long time to complete. During this operation application becomes unresponsive.

To avoid this, we can tune the JVM Heap/ other settings. Different JVMs have different GC policy algorithms which will be discussed in the next posts.


If we add the following option to the command line for the JVM:
we will get the information about the heap and result of the garbage collection for each collection.

[GC 325407K->83000K(776768K), 0.2300771 secs]
[GC 325816K->83372K(776768K), 0.2454258 secs]
[Full GC 267628K->83769K(776768K), 1.8479984 secs]
In this scenario we can see two minor GC and one Full/ Major GC.

  • First numbers stand for the size of live objects before and after the GC.
  • Numbers in parentheses represent memory space usable for java objects (perm/ survivor spaces not included).
  • Secs stands for the amount of time in seconds that was taken to perform the action
[GC [DefNew: 64575K->959K(64576K), 0.0457646 secs] 196016K->133633K(261184K), 0.0459067 secs]
Here the second numbers represent the heap usage reduction (196016K -> 133633K(261184K)

If we want to get even more details on the GC results we can add the following options:


If we add:


we will get additional information regarding timestamps when the GC occurred  Based on such results we can see how often GC occurs.


What is - EJB - Enterprise Java Bean


EJB - Enterprise Java Beans is a server-side components written in Java programming language that encapsulate business logic of an application.

Types of EJBs: Session, Entity, Message-Driven


Properties of EJBs:

  • EJB has distributable and deployable business logic to clients
  • EJB is reusable across application servers
  • EJB executed within container that provides management and control services

EJB Modules contain: 
class files for enterprise beans, and EJB DD (Deployment Descriptors). Such modules are packed as JAR files.

There are three types of EJBs:

  • Session
  • Entity
  • Message-driven (v 2.0)

Session EJBs
Session EJB is an object, non-persistent, that lives only between client and EJB. If the user fails to remove the session EJB, it will be removed after a period of time. In order to share the sessions between the clients, we have two types of session EJBs:

  • Stateful - addressed for particular client
  • Stateless - shared among all the clients

Entity EJBs (deprecated)
Entity EJBs are for persistent objects. These are mainly used for mapping DBs with applications. 
Its persistence is delegated to the EJB container or is managed on its own. 
In EJB 3.0, entity beans were superseded by the Java Persistence API (which was subsequently completely separated to its own spec as of EJB 3.1). Entity Beans have been marked as a candidate forpruning as of Java EE 6 [1][2] and are therefore considered a deprecated technology.


Message-Driven EJBs

Message driven beans collect/ retrieve messages in asynchronous mode. When message arrives it usually triggers particular function. Clients can subscribe to specific topics and be informed upon message arrival.

what is JavaBean


JavaBeans are reusable components for Java.

JavaBeans are classes with objects encapsulated into single object that is a Bean.


JavaBeans are:
- serializable objects

- have public 0-argument constructor
- allow access to private properties using just getter and setter methods.


Java vs J2EE vs JEE - Java Enterprise Edition Explained


  • Java - is a programming language
  • JEEJava Enterprise Edition based on Java 1.5+ - is a platform as a collection of technologies based on Java, for developing and deploying enterprise applications. The J2EE platform consists of a set of services, application programming interfaces (APIs), and protocols that provide the functionality for developing  highly available, scalable, secure, modular applications.
  • J2EE - older 'version' of J2EE based on java <1.5
  • JEE = Web Clients (HTML/XML) + Web Components (Servlets/ JSP) + Business Components (EJBs)
  • JEE Components - self-contained functional software assembled into JEE application with its related classes and files, and communicates with other components. In most cases component provides specific function and is part of a larger program and runs within container. Example components:
  • JEE Container - maintains individual components, it is the interface between a component and the low-level platform specific functionality that supports the component. Before a Web, enterprise bean, or application client component can be executed, it must be assembled into a J2EE application and deployed into its container.
  • JEE Modules - one or more JEE components for the same container type and one component DD (Deployment Descriptor) of that type.


JEE stands for:

"Java Enterprise Edition based on Java 1.5+ - is a platform as a collection of technologies based on Java, for developing and deploying enterprise applications"

JEE consists of many different technologies. Main parts are:

Application Components - Components are self-contained functional software assembled into JEE application with its related classes and files, and communicates with other components. In most cases component provides specific function and is part of a larger program and runs within containerExample components:
  • Client components - Application clients / applets
    • native/ 'fat' applications
    • applets on the user side

Containers - Every kind of component sits within a container and has one container.
Containers also provide a declarative mechanism for configuring applications and components during assembly or deployment through the DD (deployment Descriptors). Inside one container we can have several applications with different DDs. Example containers:
  • Web Containers
    • Web Containers provide runtime support for the user requetsts and produce responses based on the form and variables in the request. Process usually startes the execution of Servlets or JSP.
  • EJB Containers
    • These provide EJB (Enterprise Java Beans) components by automated support for transaction, security, persistence, and life cycle management of deployed components. 
  • Resource managed drivers - resource adapters
    • these are mainly drivers that provide connectivity to an external components. 

Difference between JSP and Servlet


  • Servlet - html in java
  • JSP - java in html


JSP (Java Server Pages) are pages that contain Java code that is put between HTML content in order to produce specific output. JSP page is compiled into Servlet at runtime, cached and presented for the end-user.

Servlet - is a Java class that produces specific output for the user. By using Java Servlet API, as a part of JEE, it responds to the requests in a specific way.

Why do people use both solutions instead of just one?

JSP can be considered more as a scripting language, hence it's easier/ faster to write and created
dynamic content.
JSP is compiled into Java Servlet (and then cached, but renewed whenever contents change).
JSP is used more as a View component, whereas Servlet is considered as Controller in the MVC (model-view-controller architecture).
Servlets by definition are faster than JSP, and should be used more for processing the data than displaying content.

// from

import javax.servlet.http.*;
import javax.servlet.*;

public class HelloServlet extends HttpServlet {
  public void doGet (HttpServletRequest req,
                     HttpServletResponse res)
    throws ServletException, IOException
    PrintWriter out = res.getWriter();

    out.println("Hello, world!");
An example of a JSP mixing HTML and Java code:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!doctype html>
Hello, world! Your IP address is <%= request.getRemoteAddr(); %>!

if (request.getParameter("test") != null) {
  <p><strong>Something happened!</strong></p>