JDK Debugging Tools

1. Build "AnagramGame" application through NetBeans and run at the command line
2. Use "jps"
3. Use "jconsole"
4. Use "jmap" with heap dump option
5. Use "jmap" with history option
6. Use "jhat"
7. Use "jstat"
8. Use "jstack"
   

• Select File->New Project. (Figure-1.10 below)

• Select Finish (Figure-4.12 below)

• Right click the AnagramGame project node and select Properties.
• Select Sources and make sure the Source Level is set to 1.6.  (Figure-4.13 below)
• Click OK.

• Right click the AnagramGame project and select Clean and Build Project.
• Note that you can run the program at the command line by typing  java -jar "C:\myprojects\AnagramGame\dist\anagrams.jar".  (You will run the application at the command line later to simulate a locally running Java application.)

• Right click project node and select Close.

• Open a terminal window and type java -jar "C:\myprojects\AnagramGame\dist\anagrams.jar". 
  

• Observe that the Anagrams GUI interface appears.
• Type in abstraction and click Guess.

• In a terminal window, type "jconsole".  (Or you can double click jconsole within then explorer.)
  

• Observe that the JConsole: New Connection window appears.
• Select anagram.jar.
• Click Connect.
  

• Print shared object mappings for a process, a core file, or a remote debug server.
• Dump the Java heap (all objects or only live objects) of a process, a core file, or a remote debug server in binary format to a file.
• Force the Java heap dump of a process if the process does not respond.
• Print a heap summary for a process, a core file, or a remote debug server.
• Print a histogram (all objects or only live objects) of a process, a core file, or a remote debug server.
• Print information on objects awaiting finalization.
• Print class loader statistics of the permanent generation.
• Pass flags to the VM.

• Execute standard queries, for example, classes, objects, class instances, reference chains from object rootset, reachable objects, and more.
• Turn on or off object allocation tracking.
• Turn on or off object reference tracking.
• Specify objects to exclude from "reachable objects" query.
• Pass flags to the Java VM on which jhat is running.
• Develop custom queries with buit-in Object Query Language.
• Compare objects in two dumps.

• From your browser, go to http://localhost:7000.
  

select f.referent from java.lang.ref.SoftReference f 
    where f.referent != null

1. Display Call stack on OutOfMemoryError exception (due to the lack of heap space)
2. Display Call stack on OutOfMemoryError exception (due to the lack of perm space)
3. Use JConsole to monitor the memory usage
4. Display JVM data through JMX
   

• Select File->Open Project (Ctrl+Shift+O). The Open Project dialog box appears.
• Browse down to <LAB_UNZIPPED_DIRECTORY>/javase6tools/samples directory. 
  
• Windows: If you unzipped the 1516_javase6tools.zip file under C:\ directory, the directory to which you want to browse down should be C:\javase6tools\samples.
• Solaris/Linux: If you unzipped the 1516_javase6tools.zip file under $HOME directory, the directory to which you want to browse down should be $HOME/javase6tools/samples.
• Select MemoryConsumer. 
• Click Open Project Folder. 
  
• Observe that the MemoryConsumer project node appears under Projects tab window.

• Right click MemoryConsumer project node and select Properties.
  

• For the Main Class field, observe memory.MemoryConsumer.
• For the VM Options field, observe -Xms10m -Xmx20m -XX:MaxPermSize=10m.  With this change,  the Heap space is limited to 20M and perm space is limited to 10M.
  

• Right click MemoryConsumer project node and select Run.
  

• Observe that the Java dialog box appears.
• Press Add More button multiple times until you experience java.lang.OutOfMemoryError exception.  Pressing Add More button keep consuming heap space.
  

• Observe that the Output window of the IDE displays java.lang.OutOfMemoryError: Java heap space exception.

• In NetBeans' output window, click on the line containing the error message.
  
• Observe that the editor window will automatically displays the relevant code.  By analyzing the call stack, one can track down the cause of the OutOfMemoryError exception, which is caused because the jButton4ActionPerformed method, which is called you press the Add More button, continues creating new MyObject  object instances.  

• Study MyObject method below.  From the code, we can see every MyObject contains a usage of a 1,000,000 long String. So when the program constantly creates new MyObject, it also creates these long strings. When simulator can't allocate more space from Heap, the OutOfMemoryError exceptipon occurs.

• Click the X button on the upper and right side of the GUI.
  

• Right click MemoryConsumer project node and select Run.
• Observe the GUI gets displayed.

• Click Non Heap Memory tab.
• Keep pressing Add More button until you experience OutOfMemoryError exception.
  

• Observe that the OutOfMemoryError exception occurs on PermGen space.
  

The detail message PermGen space indicates that the permanent generation is full. The permanent generation is the area of the heap where class and method objects are stored. If an application loads a very large number of classes, then the size of the permanent generation might need to be increased using the -XX:MaxPermSize option.

Interned java.lang.String objects are also stored in the permanent generation. The java.lang.String class maintains a pool of strings. When the intern method is invoked, the method checks the pool to see if an equal string is already in the pool. If there is, then the intern method returns it; otherwise it adds the string to the pool. In more precise terms, the java.lang.String.intern method is used to obtain the canonical representation of the string; the result is a reference to the same class instance that would be returned if that string appeared as a literal. If an application interns a huge number of strings, the permanent generation might need to be increased from its default setting.

When this kind of error occurs, the text String.intern or ClassLoader.defineClass might appear near the top of the stack trace that is printed.

The jmap -permgen command prints statistics for the objects in the permanent generation, including information about internalized String instances. See 2.6.4 Getting Information on the Permanent Generation.

• Click the X button on the upper and right side of the GUI.

• Right click project node and select Run.
  

• In a terminal window, type jconsole or double click jconsole under <JDK-Directory>/bin.
• Observe that the New Connection dialog box appears.
• Select memory.MemoryConsumer from the list.
• Click Connect.
  

• Click Memory tab.  Under memory page, it shows the different usage status for the different internal memory area. The center graph shows the current memory usage status.   You can also enlarge or decrease the graph granulites by changing the time range.  Watch the granulites change as you change the time range. In the lower part of the screen, by looking at the numbers, you can monitor the memory space used, space allocated, maximum space allowed, and information on garbage collection.

• In the application GUI, click Add More button just once.
  

• Observe the heap space graph spiked up in the JConsole.
  

• Close the application.
  

• Select Windows from top-level menu and select Task List.
  

• Observe that the Task List pane gets displayed in the bottom of the IDE with three TODO lists.
  

• In the "Task List" panel, double click on "//TODD: get an instance of MemoryMXBean here" (the first of the three).
• Observe that the editor window shows where the corresponding code is. 
  
• Add code as shown below. 
  

• Observe that there is a compile error condition.
• Right click any point in the editor window and select Fix Imports.  (Or you can wait until the 3rd TODO list is done.)
  

• In "Task List" window, double click on ""//TODO: get a snapshot of memory usages for both heap and non-heap" (the second of the three)
• Observe that the editor window shows where the corresponding code is. 
  
• Add code as shown below.   Here we are taking a snapshot of current JVM memory usage through the MemoryMXBean instance.

• Observe that there is a compile error condition.
• Right click any point in the editor window and select Fix Imports.
  

• In "Task List" window, double click on "//TODO: connect memory information to jLabels accordingly" to jump to the corresponding code.
• Observe that the editor window shows where the corresponding code is. 
  
• Add code as shown below.  Here we link the memory usage data obtained  to related Labels. Every time we click, the values for these Labels will be renewed.

• Observe that there is a compile error condition.
• Right click any point in the editor window and select Fix Imports.
  

• Click on "Design" tab. 
  
• Right click "GC" and select "Events"->"Action"->"actionPerformed".
  
• Observe that the code of the  jButton2ActionPerformed() method gets displayed in the editor window..

• Add the code to the jButton2ActionPerformed() method as shown below.  Here, the mb varaible refers to the MemoryMXBean we got in the previous step.  By invoking gc() method,  we ask the system to perform the garbage collection.

• Observe the finished code look as shown below.
  

• Right click the project node and select Run.
  
• Click "Add More" button just once.
• Observe that Used Heap Size value changes.
  

• Click "Add More" button one more time.
• Observe that the Used Heap Size value changes.

• In MemoryConsumer application, click on "Clear" and then "GC".
  
• Watch Heap usage space decrease in the JConsole. This is because in MemoryConsumer program, gc() method was modified through MemoryMXBean and the trash was forced to be collected.

1. Build and run DeadlockThreads application.
2. Use JConsole to detect a deadlock
3. Analyze the code
   

• Select File->Open Project (Ctrl+Shift+O). The Open Project dialog box appears.
• Browse down to <LAB_UNZIPPED_DIRECTORY>/javase6tools/samples directory. 
  
• Select DeadlockThreads. 
• Click Open Project Folder.
  

• Observe that the DeadlockThreadsproject node appears under Projects tab window.

• Right click DeadlockThreads project node and select Run.
  

• Select deadlock.DeadlockThreads under Local Process section.
• Click Connect.
  

• Select Threads tab.
• Click Detect Deadlock at the bottom of the JConsole.
  

• Observe that there are two threads, which appear under Deadlock tab.
• Click pool-1-thread-2.
• Observe that the information on the pool-1-thread-2 thread appears on the lower and right side of the JConsole.
  
• Observe the state of the thread is "BLOCKED on deadlock.Friend@19762f owned by: pool-1-thread-1."
  

• Click pool-1-thread-1.
• Observe that the information on the selected thread appears on the lower and right side of the JConsole.
• Observe the state of the thread is "BLOCKED on deadlock.Friend@6835fb owned by: pool-1-thread-2."