Garbage collection was first invented by John McCarthy in 1958 as part of the implementation of Lisp..

Garbage collection organizes objects into generations (Young, Tenured and Perm)..
The young generation consists of eden plus two survivor spaces .Objects are initially allocated in eden. One survivor space is empty at any time, and serves as a destination of the next, copying collection of any live objects in eden and the other survivor space. Objects are copied between survivor spaces in this way until they are old enough to be tenured, or copied to the tenured generation.

The permanent generation is special because it holds data needed by the virtual machine to describe objects that do not have an equivalence at the Java language level .For example objects describing classes and methods are stored in the permanent generation.

The garbage collection can be of 2 types namely:

• Major
• Minor

When the young generation fills up it causes a minor collection. Minor collections can be optimized assuming a high infant mortality rate.

A young generation full of dead objects is collected very quickly. Some surviving objects are moved to a tenured generation. When the tenured generation needs to be collected there is a major collection that is often much slower because it involves all live objects.

Performance considerations:

*Throughput: Percentage of time not spent in GC over a long period of time.
*Pauses: Application unresponsive during GC
*FootPrint : working set of a process, measured in pages and cache lines.
*Promptness: time between when an object becomes dead and when the memory becomes available

Where we can apply or consider about these above terms?

Lets take an example .Consider the metric for web server application to be Throughput, since Pauses during GC may be tolerable, or simple obscured by network latencies. However, if its an gaming application or interactive graphics application even short Pauses may affect the user experience..

A very large young generation may maximize the Throughput, but remaining 3 will be at expense.. If Young generation is small, then Pauses will be minimized but at the expense of Throughput. We can determine the necessary generation based on the user requirement and the application the way it uses the memory..

How do we measure?

Throughput of web server – can be tested using load generator
Footprint – in Solaris pmap command
Pauses – diagnostic output of virtual machine..

Diagram :

Sizing the Generations

• The -Xmx value determines the size of the heap to reserve at JVM initialization.
• The -Xms value is the space in memory that is committed to the VM at init. The JVM can grow to the size of -Xmx.

Total Heap:

• Total available memory is the most important factor affecting GC performance
• · By default the JVM grows or shrinks the heap at each GC to keep the ratio of free space to live objects at each collection within a specified range.

• -XX:MinHeapFreeRatio – when the percentage of free space in a generation falls below this value the generation will be expanded to meet this percentage. Default is 40
• -XX:MaxHeapFreeRatio – when the percentage of free space in a generation exceeded this value the generation will shrink to meet this value. Default is 70

Young Generation Guarantee

• The -XX:SurvivorRatio option can be used to tune the number of survivor spaces.
• Not often important for performance
  • -XX:SurvivorRatio=6 – each survivor space will be 1/8 the young generation
  • If survivor spaces are too small copying collection overflows directly into the tenured generation.
  • Survivor spaces too large uselessly empty
  • -XX:+PrintTenuringDistribution – shows the threshold chosen by JVM to keep survivors half full, and the ages of objects in the new generation.
• Server Applications
  • First decide the total amount of memory you can afford to give the virtual machine. Then graph your own performance metric against young generation sizes to find the best setting.
  • Unless you find problems with excessive major collection or pause times, grant plenty of memory to the young generation.
  • Increasing the young generation becomes counterproductive at half the total heap or less (whenever the young generation guarantee cannot be met).
  • Be sure to increase the young generation as you increase the number of processors, since allocation can be parallelized.

Types of Collectors

• Everything to this point talks about the default garbage collector, there are other GC’s you can use
• Throughput Collector – Uses a parallel version of the young generation collector
  • -XX:+UseParallelGC
  • Tenured collector is the same as in default
• Concurrent Low Pause Collector
  • Collects tenured collection concurrently with the execution of the app.
  • The app is paused for short periods during collection
  • -XX:+UseConcMarkSweepGC
  • To enable a parallel young generation GC with the concurrent GC add -XX:+UseParNewGC to the startup. Don’t add -XX:+UseParallelGC with this option.

Recommend to study this :
http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html

Java HotSpot VM Options
http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp

Examples with explanation:
http://www.javapassion.com/handsonlabs/javaperf/index.html

Netbeans Profiler with screenshot:
http://www.javapassion.com/handsonlabs/nbprofilermemory/index.html

MemoryLeak :
http://netbeans.org/kb/articles/nb-profiler-uncoveringleaks_pt1.html

I would like to share my experience and materials which I have used for SCEA preparation..Firstly, I am having 2 yr 10 months experience. Those who are having exp less than 4 yrs ,I would suggest them to finish these certifications (SCWCD, SCBCD & SCDJWS for J2EE 5) , though it’s not mandatory, but it helps you to gain more knowledge. If you are 5 + exp, then its easy to clear this exam..Exam contains only scenario based questions and we need to select an appropriate answer. It’s quite difficult for me, to choose those answers :’( . Don’t go for most powerful and new ones instead read the question carefully and address the requirements. For example, sometime two-tier architecture will be better than 3-tier, DAO over JPA, RMI over web services (it depends on our requirements )..

How long did you prepare for this exam?
I am not brilliant, little bit dumb fellow , so I took hardly 4-5 months..

Below topics are very important (If you want to be an architect, you must know about these topics in depth) . I got most of the questions from these topics..

• Business Tier Technologies(EJB,JPA): Cleared SCBCD 5

• Web services(JAXWS,SOAP,UDDI,JAXB): Cleared SCDJWS 5.

• Web Tier Technologies(Servlet,JSP): Cleared SCWCD 5 ..

• Design pattern : I read “Design Patterns”, GoF , Core J2EE Patterns, 2nd ed , Java Design Patterns & Examples(Author: Pawan Modi). I took nearly 1 month to complete this 3 books and forget completely within an week .. So I would urge you to take notes (about pros & cons) and implement those patterns so that you will remember.. Please don’t memorize, understand why we need that pattern and try to describe each pattern in a single line.. If you are able to do that, then go for next chapter.

• JCA ,JMX ,JSF – I don’t have much exposure on this ,only theory knowledge ..

• CORBA,IIOP , RMI JRMP, Java IDL -I studied CORBA in College (had few ppts to revise), implemented Java IDL.

• Cryptography alg– MD5,SHA1,Diffie-Hellman, DES (I have implemented this algorithms in C while in College , we had separate paper for cryptography )

• Message Digest ,Digital signature,One-Way Hash Function, Digital Certificates, Asymmetric Ciphers – I have implemented this in my first project (Channel level as well as message level secuirty using https – web services(signing the soap msg) – CA signed jar ….

• SSO: – I have implemented Cross-domain SSO in my second project ..So I have fair idea about this federation concept using Sun Access Manager as well as using Siteminder..

• Security: I have basic knowledge on hacking stuffs as well as on JAAS,JSSE .. SQL injection, Cross site scripting, Denial of Service (DoS), Weak Encryption, Buffer Overflow, Man in middle (We have learned these topics while in College)…

Material which I have used?

Objectives:
http://in.sun.com/training/catalog/courses/CX-310-052.xml

SCEAFaq:
http://faq.javaranch.com/java/SceaLinks

Books for SCEA Exam

Mikalai Zaikin’s notes – Thanks a ton
http://java.boot.by/scea5-guide/
Updated version, we can find here :
http://www.scribd.com/doc/25297376/J2EE-5-Architect-Exam-Study-Guide
Chapter wise – book detail (thanks to prathap venkata )
http://www.coderanch.com/t/474062/java-Architect-S…tification/books-new-scea-exam
IBM’s Java certification success
http://www.scribd.com/doc/7317384/Java-Certification-SCEA
Java EE from SUN :
http://download.oracle.com/javaee/5/tutorial/doc/

Notes:
http://www.coderanch.com/t/149662/Architect-Certif…ation/My-SCEA-Part-Study-Notes

Blogs :
http://javaxcross.blogspot.com/2008/03/how-to-pass-scea-5.html
http://jeemind.blogspot.com/2010/04/scea-cx-310-052-simulator.html
http://www.javabeat.net/cert/scea/mock-exam/scea-mock-exam-questions-10.php (Mock exam)

Design pattern :
http://www.javacamp.org/designPattern/index.html
http://sourcemaking.com/design_patterns/flyweight/java/4
http://www.java2s.com/Code/Java/Design-Pattern/CatalogDesign-Pattern.htm
Liskov Substitution Principle/ Designing Abstraction/ Dependency Inversion Principle
http://javaboutique.internet.com/tutorials/JavaOO/

Security:

JavaRanch:
http://faq.javaranch.com/java/SecurityFaq
JavaEE tutorial , Security chapter .. http://download.oracle.com/javaee/5/tutorial/doc/javaeetutorial5.pdf
Cyp: Basics
http://www.javapassion.com/j2ee/SecurityBasics.pdf
Web security:
http://www.javapassion.com/j2ee/WebApplicationSecurity.pdf
Threats:
http://www.javapassion.com/j2ee/WebSecurityThreats.pdf
X509:
http://www.mayrhofer.eu.org/Default.aspx?pageindex=4&pageid=39

Servicelocator Vs Ejb 3 injection:
http://www.javalobby.org/articles/service-locator/

DOA Issue :
http://www.coderanch.com/t/458380/Architect-Certif…on/DOA-as-session-bean#2046792

Obsolete Design Patterns for EJB3 & SCEA 5 :
http://www.coderanch.com/t/156191/Architect-Certif…olete-Design-Patterns-EJB-SCEA

Please drop a comment , I would like to help & share notes with all..

All the best

*) Basic flow architecture of java – Read abt JVM, why we need JRE, Where we will be using JIT, CLASSLOADER workflow..

*) We should be good in core java concepts.. I would prefer to read Kathy serria (SCJP book).. Its not mandatory to take this SCJP exam, but its better to read this book atleast once and be familiar with all the topic.. Concentrate more on Threads,Generics & Collections (especially HashMap implementation).. I would urge you to code as much as possible.. Understand HashCode concept, implement a simple HashMap (what will happen if collision occurs in HashMap) , LoadFactor, rehash ,running time complexity(O(1)) .. Please check the source code of HashMap.java

*) Annotation – how to create a simple annotation (@Retention(RetentionPolicy.RUNTIME))

*) Task Scheduling Framework – [Executor & Future , Concurrent.* package ]

*) Interview questions – Arul kumaran (Search in Google, it’s a free source).. Read all the questions…

*) Design patterns… Please be familiar with 5-6 common pattern.. Singleton, Factory, Abstract Factory, Observable & Observer…
J2EE pattern – we should know basic things [ ServiceLocator , BussinessDelegate, DAO, SessionFacade ,FrontController ,Interceptor ]

http://www.javacamp.org/designPattern/

http://www.java2s.com/Code/Java/Design-Pattern/CatalogDesign-Pattern.htm

*) I have shared some more interview questions : here

*) JSP:

- Jsp life cycle
- Declaration <%! %>-understand the significance of !.. <%! String name=”vignesh”; %> is an instance variable declared outside _jspService() whereas <% String name=”vignesh”; %> is a local variable declared inside _jspService().
-Jsp page directive (import,isErrorPage,extends)
-Implicit variables (request,response,session,page ..etc)
- Custom Tag
- Difference between <%@include>

*) Servlet:
- GenericServlet, Servlet (check whether its a interface or class or abstract class).. Understand the core flow.. It sounds better, if we analyze these things..
- Life cycle
- ServletContext & ServletConfig (Imp)
- Cookie, UrlRewriting , session
- RequestDispatcher.forward() Vs HttpServletRe sponse.sendRedirect()
· forward- handled on server side. Transparent to browser
· redirect – sends redirect message to the browser
- Session affinity and sticky session in context of load balancing servers
- Understand about Http protocol
- Filter, Listener

Must read links:

J2EE-Clustering : here

Memory(OS memory + heap memory + outOfMemoryError) : here

Object creation in GC: here

Java Anti-Patterns : here

Supercharging your HashMaps & Pagination using JDBC and JSP: Both are discussed very briefly, one should understand abt this : here

Tuning Garbage Collection: (Must read and should know about young n tenured collection) here

String or Stringbuffer used as a key in HashMap .Which one is better: here

Reference (Strong,Weak,soft,Phantom) : here

How https can be used to maintain session state:here

Load balancing: here

Class format: here

Filter:here

Servlet: here

Javap: here

Please leave your comments , so that I can add more ques ..

I love this project, its about cloud computing and mainly virtualization as well as its going to be competitor to big companies..

First round :

*Tell about myself and about project
*project related questions , so many questions related to web services & its security level
*comparable & comparator
*Jsp – life cycle
*Web.xml – elements
*Wsdl- how to validate
*wsdl explanation -with elements (types,message,portType,binding,Service)
*wsdl -Soap binding -Document & rpc
*replicating the values in clusters
*web services – jax rpc
*Jax Ws
*continuous integration – maven to bundle,checkStyle to check,PMD validation and finally deployment
*maven & ant
*classloader , war loader
*common jar between two war,how to share that jar to those war file.. Meta-inf – Manifest file
*autoboxing & var args ..said abt println method in c, hw its copied from C program to java..I have explained in depth(C – flow)
*strategy pattern -didn’t answer this question
*session facade , business delegate,dao pattern
*factory pattern
*abstract class – y we need to use and whr we will use
*ORM – hibernate , hibernate typical properties
*Sax,Dom,STAX,JAXB
*Channel level & message level security
*how will you manage session in web service
*https & http
*Dcache -replicating in clusters , in memory handler
*struts – Dynamic action
*scope of form type in struts
*tilesplugin
*Transaction — two phase commit protocol
*ReadWrite – Isolation
*Axis ..
*AJAX – xmlhttprequest,jmaki,GWT
*Dependency Injection
*Aspect oriented programming
*how to sort ArrayList using comparator (Collections)..
*Junit – TestCases,Suite
*Annotation -Retention Policy
*Log4j -adapter,Layout
*JNDI
*UML – Aggregation ,Association
*Unix – shell & system programming
*Abt cloud computing,,,
*Virtualization

More to add on….

Proxy.py

import urllib2
#Browser proxy setting
proxy_info = {
‘user’ : ‘vignesh_v’,
‘pass’ : ‘passwd’,
‘host’ : “10.16.65.13″,
‘port’ : 80
}

# build a new opener that uses a proxy requiring authorization
proxy_support = urllib2.ProxyHandler({“http” : \
“http://%(user)s:%(pass)s@%(host)s:%(port)d” % proxy_info})
opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler)
# Install the opener
urllib2.install_opener(opener)
#Open the url
f = urllib2.urlopen(‘http://www.python.org/’)
print f.headers
print f.read()

Please install this webpy module

Note: User have to align the below code..

SmsAppMain.py

#imports the web.py module
import web
#Import inbulit sqlite db
import sqlite3

#Creating the connection
global connection
connection = sqlite3.connect(‘smsapp.db’)
#Load the cursor
global cursor
cursor = connection.cursor()

def createUser():
#Create the usertbl
cursor.execute(”’create table usertbl(username text,passwd text)”’)
print ‘Created Usertbl’
# Insert a row of data
cursor.execute(“”"insert into usertbl values (‘viggi’,'test’)”"”)
# Save the changes
connection.commit()

def retrieveUser(name):
import sqlite3 as db
db = web.database(dbn=”sqlite”,db=”smsapp.db”)
#Get a reference to the connection object via the cursor
connection = db._db_cursor().connection
cursor.execute(‘select * from usertbl’)
for element in cursor:
strUser = element
return strUser

#look for templates in your templates directory
render = web.template.render(‘templates/’)

#Regex that matches a URL,like /,/help
urls = (“/.*”, “SmsAppMain”)

#Class with GET function
class SmsAppMain:
def GET(self):
name = ‘Viggi’
#createUser()
strUser = retrieveUser(name)
#index is the name of the template
return render.index(str(strUser))

if __name__ == “__main__”:
#Create an application with the URLs
#looking up the classes in the global namespace
app = web.application(urls, globals())
app.run()

index.htm:

$def with (name)
$if name:
hello to $name.
$else:
Hello, dumb

Create the templates folder and copy this index.htm…
cmd : python SmsAppMain.py

Open a browser and hit this url http://localhost:8080/index.htm

References :

http://webpy.org/skeleton/0.3

http://docs.python.org/library/sqlite3.html

For given source vertex(node) in the graph ,the alg will find the shortest path between the vertex and with every other vertex.

Ex: Finding shortest route between one city and all other cities..

Alg desc :
Entities :
Vertices- (nodes)
Edges -> links between vertices

Note : distance between 2 vertex is always positive..

All the vertices in the graph will be consider as unsettled vertices.. so we will maintain two sets (settled and unsettled)..Alg ends once all the vertices are in the settled set.Vertex will be moved to settled set,once its shortest distance has been found.

E -> Stores the shortest distance from the source to each vertex..
D -> store the predecessor of each vertex  on the shortest path from the source..
X -> set of settled vertices, ie the vertices whose shortest distance from d source have been found
F- > unsettled Vertices..

E= $ -> represents infinity
D = () empty set
X = F = () empty set

add vertex to F
E(vertex) =0;
while F is not empty
{
vertex_A =find_minimum(F);
add vertex_A to X ;
find_neighbor(vertex_A);
}

find_minimum(F)
{
find the smallest (as defined by E) vertex in F
remove it from F and return it
}

find_neighbor(shortest_distance )
{
for each vertex_B adjacent to vertex_A, vertex_b not in X
{
if(d(vertex_B) > d(vertex_A) + [vertex_A,vertex_B] //shorter distance exists
{
d(vertex_B) = d(vertex_A) + [vertex_A,vertex_B]
D(vertex_B)=vertex_A
add vertex_B to F
}
}
}

More to add… soon i will update with an example and their run time as well as desc for complexity of this alg..

Source :

http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm

http://renaud.waldura.com/doc/java/dijkstra/

Naive soln :

• First find the total number of nodes, by iterating the entire list ..
• Now subtract the nth last node from the total number
• Now again iterate from the head node to the nth node…

But it require two complete iteration..

Optimized soln :

• Create two pointers and point those pointers to head node..
• Iterate first pointer to nth node..
• Now, iterate both first node pointer and second node pointer, until first node pointer reaches the end of the list .. Now second pointer will be pointing to the nth node from the last node..

List :
We need to find 3^rd from the last, that is 40

P1 – pointer 1  & P2- pointer 2  both pointing to head node

P1 Iterate first pointer to nth node.. ie n=3

Iterate both first node pointer and second node pointer, until first node pointer reaches the end of the list

Program :

/**
 *
 * @author vignesh_v
 */

class LinkedList {

    LinkedList nextNode;
    int data;

    LinkedList(int data) {
        this.data = data;
    }

    void display() {
        System.out.println("Value " + data);
    }
}

class LinkedListCreation {

    LinkedList firstNode;

    LinkedListCreation() {
        firstNode = null;
    }
    //Adding datas to LinkedList

    void insert(int data) {
        LinkedList list = new LinkedList(data);
        list.nextNode = firstNode;
        firstNode = list;
    }

    void display() {
        LinkedList currentNode = firstNode;
        while (currentNode != null) {
            currentNode.display();
            currentNode = currentNode.nextNode;
        }
    }

    LinkedList findNthLast(int n) {
        //Create two pointers and point those pointers to head node..
        LinkedList pointerNode1 = firstNode;
        LinkedList pointerNode2 = firstNode;
        //Iterate first pointer to nth node.. 
        for (int i = 1; i < n; i++) {
            if (pointerNode1 == null) {
                return null;
            } else {
                pointerNode1 = pointerNode1.nextNode;

            }

        }
        //Iterate both first node pointer and second node pointer, 
        //until first node pointer reaches the end of the list .. 
        //Now second pointer will be pointing to the nth node from 
        //the last node..
        while (pointerNode1.nextNode != null) {
            pointerNode1 = pointerNode1.nextNode;
            pointerNode2 = pointerNode2.nextNode;
        }
        //nthLastNode
        return pointerNode2;
    }
}

public class TestLinkedList {

    public static void main(String[] a) {
        LinkedListCreation listCreation = new LinkedListCreation();
        listCreation.insert(20);
        listCreation.insert(30);
        listCreation.insert(40);
        listCreation.insert(50);
        listCreation.insert(60);
        listCreation.insert(70);
        listCreation.insert(80);

        listCreation.display();
        LinkedList listFound = listCreation.findNthLast(3);
        if (listFound != null) {
            listFound.display();
        }
    }
}

com.sun.tools.javac.Main class has two methods which help us to invoke the compiler from a program. It will behave like javac command.
public static int compile(String []args);
public static int compile(String []args , PrintWriter out);

args-> command line arguments that would be normally be passed on the javac program.
out-> indicates where the compiler’s output is directed.
return (int) -> exit value

I would like to share a simple program which will create a java file on the fly (ie at Runtime) and it will be compiled using compile method provided by this class com.sun.tools.javac.Main.Once its  been compiled,using reflection apis we will invoke the method in the class(which is created at Runtime)..

import java.io.FileWriter;
import java.lang.reflect.Method;
public class DynamicClassCreation
{
//ClassName
static final String className=“DynamicTestClass”;
static final String fileName=className+“.java”;

public static void main(String []a)
{
createClass();
}
public static void createClass()
{
String methodName=“execute”;
String parameterName=“strParam”;
try{
//Creates DynamicTestClass.java file
FileWriter fileWriter=new FileWriter(fileName,false);
fileWriter.write(“public class “+ className +” {\n”);
fileWriter.write(“public String “+methodName +“(String “+parameterName+“) {\n”);
fileWriter.write(“System.out.println(\” Testing\”);\n”);
fileWriter.write(“return “+parameterName +“+ \” is dumb\”;\n }\n}”);
fileWriter.flush();
fileWriter.close();

String[] source = { new String(fileName) };
//javac -> compile method in Main class ..presents in tools.jar
//Compile the DynamicTestClass.java ,created on the fly
com.sun.tools.javac.Main.compile(source);

// Creates an object of type Class which contains the information of
// the class String
Class classObj=Class.forName(className);
// getDeclaredMethod() returns the declared methods of the class.
Method method= classObj.getDeclaredMethod(methodName,new Class[] { String.class}); //for int -> Integer.TYPE;
//Invoking the execute method and passing the value for String parameter
String returnVal =(String) method.invoke(classObj.newInstance(),new Object[] { “Vignesh”});
System.out.println(“Value return from DynamicTestClass : “+ returnVal);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

Before compiling this class, we should set the classpath for tools.jar file..

C:\java>set CLASSPATH=C:\Java\jdk1.5.0_16\lib\tools.jar;%CLASSPATH%

Compile : javac DynamicClassCreation.java
Run : java DynamicClassCreation

Note:
target option:

We have jdk 1.5, but we would like to compile the code that will run on a 1.4 VM.-target 1.4 option ensures that the generated class files will be compatible with 1.4 VMs.

EX:
javac -target 1.4 -bootclasspath jdk1.4.2/lib/classes.zip \
-extdirs “” TestClass.java

Reference:
Javac: http://java.sun.com/j2se/1.5.0/docs/tooldocs/solaris/javac.html

This material -> It would be helpful for java interview for sure (for Product company ) .. Its bit lengthy, I will try to modify this material.. Even I hate to read big paragraph, first time I took some notes and created a simple doc..  I am glad to share this with you all..

Till now, I didn’t concern about the details of what happened to the source code when it’s run through the compiler. I would like to share my findings (behind the scene details).

Javap utility is used to disassemble java bytecode (ie binary format into readable format) .This utility is included in Jdk .

Let’s start with a simple example and we try to analyze the bytecode.

public class JavaBehindTheScene
{
public static void main(String []a)
{
System.out.println(“Vignesh bhupathi”);
}
}

Once we compiled this above program, we need to execute this command “javap –c JavaBehindTheScene “ to view the bytecode.

‘-c ‘ option -> to disassemble the code.To know more options for javap, just execute javap –help.

C:\java> javap -c JavaBehindTheScene
Compiled from “JavaBehindTheScene.java”
public class JavaBehindTheScene extends java.lang.Object{
public JavaBehindTheScene();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object.”&lt;init&gt;”:()V
4: return

public static void main(java.lang.String[]);
Code:
0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3; //String Vignesh bhupathi
5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/Str
ing;)V
8: return
}

We can view two methods in the bytecode (output of javap).

First method public JavaBehindTheScene() ,it indicates the constructor of the class. Even though we didn’t declare the definition of constructor, by default it will create.

0->offset instruction from the beginning of the method.aload_0 ->prefix ‘a’ refers object reference. Similarly iload_0 -> ‘i’ refers integer,’c’- char, ’b’ –byte etc. This prefix helps us to find what type of data is being used.This opcode will push the value from index 0 of the local variable table onto the operand stack… The “this” reference is always stored at location 0 of the local variable table for the constructor & instance. It will be pushed because the method is accessing the instance data, name, of the class…

Index 0 -Usually it will store the parameters. For constructor or instance method, the reference will stored at 0.For static method, parameter is stored in location 0.

Before going into this, we will try to understand how JVM implementing this. JVM is stack based machine. Each Thread will have separate JVM stack which store frames. A frame will be created, when a method is invoked. Frame contains an operand stack, an array of local variables and reference to the runtime constant pools.

FRAME

Now back to the point, take next opcode, invokespecial -> calls the constructor of this class’s Superclass. During this opcode, the top value from the operand stack, “this”, is popped. #1 – It will helpful to build an index into runtime constant pool of the class where the reference to name is stored.

Finally opcode, return -> it will return from the constructor.

Next, we will move to the main method.

Opcode getstatic , this will get the static field ( System.out) and it will push it on the operand stack. #2 – it will put it in constant pool table at index 2.

Opcode ldc,    load the constant onto the operand stack. So it will load the string “Vignesh bhupathi” ->from index #3.

Opcode invokevirtual , This will invoke the pritnln method in System.out ,it will pop the operands in the stack and then execute the method.

Finally, we are done with the method, so it will return back.We can find more details about instruction set over here .

You may ask: what is the need to look for this bytecode? Sometime we may not sure whether the code which we try to implement is good (performance wise). So how do we analyze  the performance of the code as well as to find the size of the code ?

If we are not sure about this, then we can use this javap tool to know about the size of the opcode (by checking the bytecode) as well as we can identify the instructions (opcode) in the bytecode. This would help us to analyze the code which we have written. Let we take an example,

public class JavaBehindTheScene
{
int arr[]=new int[]{1,2,3};
public synchronized int getArr1()
{
return arr[0];
}
public int getArr2()
{
synchronized(this)
{
return arr[2];
}
}
public static void main(String []a)
{
System.out.println(“Vignesh bhupathi”);
}
}

Bytecode: javap –c JavaBehindTheScene

public synchronized int getArr1();
Code:
0: aload_0
1: getfield #2; //Field arr:[I
4: iconst_0
5: iaload
6: ireturn

public int getArr2();
Code:
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: aload_0
5: getfield #2; //Field arr:[I
8: iconst_2
9: iaload
10: aload_1
11: monitorexit
12: ireturn
13: astore_2
14: aload_1
15: monitorexit
16: aload_2
17: athrow
Exception table:
from to target type
4 12 13 any
13 16 13 any

This getArr1, getArr2 functionality wise similar but the way they have used synchronized keyword is different. We can examine the bytecode for both the method. It’s obvious to say getArr1 is good when comparing to getArr2 method. getArr2 method is larger as well as slower when compared to getArr1.

getArr1 method didn’t generate any extra opcode for synchronized keyword where as getArr2 uses synchronized in the body of the method (we can view that monitorenter , monitorexit opcode as well as additional code for handling exceptions ).For getArr2 method, lock can be handled by using this monitorenter & monitorexit opcode, where as for getArr1 method it little bit different.

When JVM invokes this method getArr1, it checks for the ACC_SYNCHRONIZED property flag. If this flag present then the Thread executing this method will acquire the lock and release the lock, once it’s done with the work.

Note: method_info structure will have this flag ACC_SYNCHRONIZED. We can find the detail here

I prefer to use the method modifier over the synchronized block in order to produce smaller bytecode as well as it run slightly faster code.

References :

http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#84874

http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Using_javap.html

http://java.sun.com/docs/books/jvms/second_edition/html/Overview.doc.html#7143

http://www.javaranch.com/journal/200408/ScjpTipLine-javap.html

http://www.ibm.com/developerworks/ibm/library/it-haggar_bytecode/