Category: technology and computing programming languages. Java VisualVM can open heap dumps saved in the. When you open a saved heap dump , the heap dump opens as a tab in the main window. What is JMAP? How do you analyze a Java heap dump? When should I take a heap dump? Taking Heap dump using jmap. What is heap memory? What is a heap dump in Java? What should I look for in a heap dump? How do you analyze heap bin?
Where is WinDbg? How do I check my memory dump? Open the dump file. Click Start, click Run, type cmd, and then click OK. How do I view a dump file? Opening Memory Dump Files. Open the Start menu. How do you use WinDbg to analyze a crash dump? Crash Dump Analysis in WinDbg. Start WinDbg. What is a DMP file can I delete it?
How do I analyze minidump files? Viewing Minidump Files. How do you run a WinDbg? Launch your own application and attach WinDbg. Understanding the Terminology Java thread dumps can appear cryptic at first, but making sense of thread dumps requires an understanding of some basic terminology.
In general, the following terms are key in grasping the meaning and context of a Java thread dump: Thread — A discrete unit of concurrency that is managed by the Java Virtual Machine JVM. Threads are mapped to Operating System OS threads, called native threads , which provide a mechanism for the execution of instructions code. Each thread has a unique identifier, name, and may be categorized as a daemon thread or non-daemon thread , where a daemon thread runs independent of other threads in the system and is only killed when either the Runtime.
For more information, see the Thread class documentation. Alive thread — a running thread that is performing some work the normal thread state. Blocked thread — a thread that attempted to enter a synchronized block but another thread already locked the same synchronized block. Waiting thread — a thread that has called the wait method with a possible timeout on an object and is currently waiting for another thread to call the notify method or notifyAll on the same object.
Note that a thread is not considered waiting if it calls the wait method on an object with a timeout and the specified timeout has expired. Sleeping thread — a thread that is currently not executing as a result of calling the Thread.
Monitor — a mechanism employed by the JVM to facilitate concurrent access to a single object. This mechanism is instituted using the synchronized keyword, where each object in Java has an associated monitor allowing any thread to synchronize, or lock , an object, ensuring that no other thread accesses the locked object until the lock is released the synchronized block is exited. For more information, see the Synchronization section Deadlock — a scenario in which one thread holds some resource, A , and is blocked, waiting for some resource, B , to become available, while another thread holds resource B and is blocked, waiting for resource A to become available.
When a deadlock occurs, no progress is made within a program. It is important to note that a deadlock may also occur with more than two threads, where three or more threads all hold a resource required by another thread and are simultaneously blocked, waiting for a resource held by another thread. A special case of this occurs when some thread, X , holds resource A and requires resource C , thread Y holds resource B and requires resource A , and thread Z holds resource C and requires resource B formally known as the Dining Philosophers Problem.
Livelock — a scenario in which thread A performs an action that causes thread B to perform an action that in turn causes thread A to perform its original action. This situation can be visualized as a dog chasing its tail. Similar to deadlock, live-locked threads do not make progress, but unlike deadlock, the threads are not blocked and instead, are alive.
Creating an Example Program In order to generate a thread dump, we need to first execute a Java application. Object 17c At the completion of this output, the program appears as though it is running the process executing this program does not terminate , but no further work is being done.
Generating a Thread Dump In practice, a Java program might terminate abnormally and generate a thread dump automatically, but, in some cases such as with many deadlocks , the program does not terminate but appears as though it is stuck.
Object at java. Object , which is held by "Thread-1" "Thread-1": waiting to lock monitor 0xe object 0xa0, a java. Introductory Information Although this file may appear overwhelming at first, it is actually simple if we take each section one step at a time. The first line of the dump displays the timestamp of when the dump was generated, while the second line contains the diagnostic information about the JVM from which the dump was generated: Full thread dump Java HotSpot TM Bit Server VM If we examine these addresses, we see that they correspond to the tid value — the address of the native thread object, not the Thread ID, as we will see shortly — of each of the numbered threads in the dump note that ellipses are used to hide superfluous information : "Reference Handler" Threads Directly following the SMR information is the list of threads.
This number is generated, starting at 1 , for all threads in the system. Each time a Thread object is created, the sequence number is incremented and then assigned to the newly created Thread. This ID is read-only and can be obtained by calling getId on a Thread object. Daemon status daemon A tag denoting if the thread is a daemon thread. Note that this does not necessarily correspond to the priority of the OS thread to with the Java thread is dispatched.
The priority of a Thread object can be set using the setPriority method and obtained using the getPriority method. This priority can differ from the Java thread priority and corresponds to the OS thread on which the Java thread is dispatched. This string provides supplementary information beyond the basic thread state see below and can be useful in discovering the intended actions of a thread i. Thread State The second line represents the current state of the thread.
Thread Stack Trace The next section contains the stack trace for the thread at the time of the dump. Locked Ownable Synchronizer The last portion of the thread information contains a list of synchronizers objects that can be used for synchronization, such as locks that are exclusively owned by a thread. JNI global references: 2 For many simple issues, this information is unused, but it is important to understand the importance of these global references.
Deadlocked Threads The final section of the thread dump contains information about discovered deadlocks. This circular dependency is the textbook definition of a deadlock contrived by our application and is illustrated in the figure below: In addition to the description of the deadlock, the stack trace for each of the threads involved is printed in the second subsection. For example, if we examine line 34 of our application, we find the following content: printLockedResource secondResource ; This line represents the first line of the synchronized block causing the deadlock and tips us off to the fact that synchronizing on secondResource is the root of the deadlock.
Object 6e41d7dd In summary, using only the information provided in the thread dump, we can find and fix a deadlocked application. Handling More Complex Thread Dumps When handling production applications, thread dumps can become overwhelming very quickly. Conclusion Thread dumps are an excellent mechanism for analyzing the state of a Java application, especially a misbehaving, multithreaded application, but without proper knowledge, they can quickly add more confusion to an already difficult problem.
Footnotes Thread SMR is an involved topic and beyond the scope of this article. The interested reader can find more information under the Hazard Pointer Wikipedia page , as well as Michael Maged's article on the topic. This thread, along with Thread-1 , are called anonymous threads because they are not explicitly named i.
The default name for anonymous threads in Java is Thread- followed by a 0-indexed ID that is incremented for each anonymous thread e. Thread-0 , Thread-1 , etc. Type yes to launch the gdb GNU Debugger interface, as suggested by the error report shown above. In the gdb prompt, you can give the gcore command. This command creates a core dump of the debugged process with the name core.
Make sure that the gdb gcore command is supported in your versions of gdb. Look for help gcore in the gdb command prompt. The following list explains the major reasons that a core file might not be generated. This list pertains to both Oracle Solaris and Linux operating systems, unless specified otherwise.
The current user does not have permission to write in the current working directory of the process. The current user has write permission on the current working directory, but there is already a file named core that has read-only permission.
The current working directory is remote. Oracle Solaris operating system only: The coreadm tool has been used to configure the directory and name of the core file, but any of the above reasons apply for the configured directory or filename. The core file size limit is too low. Check your core file limit using the ulimit -c command Bash shell or the limit -c command C shell. If the output from this command is not unlimited, the core dump file size might not be large enough.
If this is the case, you will get truncated core dumps or no core dump at all. In addition, ensure that any scripts that are used to launch the VM or your application do not disable core dump creation. The process is running a setuid program and therefore the operating system will not dump core unless it is configured explicitly.
These are the only cases in which HotSpot dumps core. The standard Java launcher was not used. The custom Java launcher program handled the signal by just consuming it and produced the log entry silently. This situation has occurred with certain Application Servers and Web Servers. These Java VM embedding programs transparently attempt to restart fail over the system after an abnormal termination.
In this case, the fact that a core dump is not produced is a feature and not a bug. Watson logfile, which is a text error log file that includes faulting stack trace and a few other details. User minidump, which can be considered a "partial" core dump. It is not a complete core dump, because it does not contain all the useful memory pages of the process. Watson full-dump, which is equivalent to a Unix core dump. This dump contains most memory pages of the process except for code pages. When an unexpected exception occurs on Windows, the action taken depends on two values in the following registry key:.
The two values are named Debugger and Auto. The Auto value indicates if the debugger specified in the value of the Debugger entry starts automatically when an application error occurs.
A value of 0 for Auto means that the system displays a message box notifying the user when an application error occurs. A value of 1 for Auto means that the debugger starts automatically. The value of Debugger is the debugger command that is to be used to debug program errors. When a program error occurs, Windows examines the Auto value and if the value is 0 it executes the command in the Debugger value. If the value for Debugger is a valid command, a message box is created with two buttons: OK and Cancel.
If the user clicks OK , the program is terminated.
0コメント