JDB - Introduction, jdb demo.

Jdb demo

In addition, we have advanced concepts that can be used to debug a program such as: there are different kinds of techniques to debug a java program.

New casino slots to play real money

The old method of debugging is by using print statements at the end of every segment which will print the trace statements on the console. Take a look at the following code.

JDB - introduction

Debugging is a technical procedure to find and remove bugs or defects in a program and get expected results. Debugging includes testing and monitoring. It is very complex when the subunits of a program are tightly coupled. We can debug a program using the debugger tools that follow the prescribed apis. A debugger allows you to step through every aspect of a code, inspect all the elements, and remove errors, if any.

Debugging techniques

There are different kinds of techniques to debug a java program. The old method of debugging is by using print statements at the end of every segment which will print the trace statements on the console. Take a look at the following code.

Here, we have a program that adds two numbers and prints the output. Notice that at each step, we have introduced a print statement that prints the state of the program on the console. This is the traditional approach to debug a program.

In addition, we have advanced concepts that can be used to debug a program such as:

• Stepping


• Breakpoints, and


• Exceptions or watchpoints.

Types of debugging

We can debug a program using various methods:

• Using java bytecode (compiled version of java code)


• Using comments inside the programs


• Attaching class to a running program


• Remote debugging


• Debugging on demand


• Optimized code debugging

Java debuggers

Here are some examples of java debuggers that are available in the market:

• Ides such as eclipse, netbeans, etc. Contain their own debuggers (visual cafe, borland, jbuilder)


• Standalone debugger guis (such as jikes, java platform debugger, and jprobe)


• Command-line debugger (sun’s JDB)


• Notepad or VI driven (stack trace)

This tutorial covers how to use the command-line debugger, jdb.

The java debugger (JDB) is a tool for java classes to debug a program in command line. It implements the java platform debugger architecture. It helps in detecting and fixing bugs in a java program using java debug interface (JDI).

JDB in JDK

The following architecture defines the role of JDB in JDK. It contains mainly three units:

• Java virtual machine tool interface (JVM TI)


• Java debug wiring pool (JDWP)


• Java debugger interface (JDI)

JVM TI

It is a native programming interface implemented by VM. It provides ways to inspect and debug the state of the application running on the VM. It allows an implementer (VM implementer) that can be enclosed easily into the debugging architecture. It also uses a third-party channel called JDWP for communication.

It defines the format of information and the requests that pass in between the debuggee process and the debugger front end. The primary purpose of having a JDWP is to allow the debuggee and the debugger to communicate when they run under separate vms or in separate platforms.

It is a high-level java interface implemented as front end. It defines the variable information at user code level. It is recommended to use a JDI layer for all debugger development. It uses JDWP for communication with the debuggee JVM.

Jdb demo

JDB example: generating a thread dump

Every once in a while I run into a situation where the usual means for generating a thread dump (stack trace) does not work, making it difficult to track down pesky deadlocks. This seems somewhat more common under OSX, but I’ve seen it happen under linux as well.

Typically you can type control-&backslash; (control-break on windows), or send a process the QUIT signal (e.G., kill -QUIT ) to dump a trace of all active threads in the java VM. Intermittently, however, I have found that this does not work for java processes that are launched via a shell script. The control-&backslash; is sometimes simply ignored, while the QUIT signal appears to kill the script, but without dumping a stack trace or killing the java process. (this suggests that in either case, the script is probably just intercepting the signal. There’s probably a fix for that, but I haven’t explored it.)

The jdb debugger utility, included as part of the JDK, provides an alternate way to get a stack trace. First, you must pass two additional arguments to the java vm to tell it to listen for connections from the java debugger. On OSX, linux, or UNIX, this looks like:

This will cause the VM to listen for debugger connections on port 8000. You may use any usued port number that the account in which the program is running may listen. For non-priviledged accounts, this typically means any port number over 1024. For security reasons you might not want to include these options on a production system, but for testing and debugging they impose no measurable performance penalty.

As an example, here is a simple deadlockdemo class that will produce a deadlock at some indeterminate point. It creates three threads, each of which will repeatedly try to randomly acquire two locks. When a thread successfully gets both locks, it will update a counter. Eventually two threads will try to acquire the same two locks in the opposite order, resulting in a deadlock. Deadlock situations are, of couse, not the only cases where stack traces are useful, but are probably the most common:

Figure 1. Deadlockdemo , a program that (eventually) deadlocks.

You can run this class from the command line thusly:

To get a thread dump, you first need to attach the debugger. In another terminal window, type:

Note that the port number (8000, in this example) must match the port number that you provided when you launched the virtual machine. You will see:

At the jdb prompt, enter " suspend " to temporarily suspend all running threads in the VM. Your program will become unresponsive after you do this. Next, enter " where all " to generate the thread dump. Here is a complete example:

Figure 2. A stack trace produced within jdb.

Here we see that our three " runner thread n " threads are all stuck at line 47 in the run method, each waiting for a lock that one of its siblings is holding. The user interface is not blocked, as the event dispatch thread (" AWT-eventqueue-0 ") is waiting for another input event. The other threads are handling various background tasks in the VM.

To exit jdb, type " quit ". Your program, with the exception of any deadlocked threads, will become responsive again. If you do not wish to exit out of jdb, you can type " resume " instead of " quit " to undo the effects of " suspend ". Note that you can only generate a thread dump when threads are suspended.

On windows, a slightly different mechanism is used for communication between the java virtual machine and JDB. Rather than specifying a port for the connection, you tell the VM to use shared memory. Here's what the command would look like for the deadlockdemo example on windows:

To connect jdb to the virtual machine, enter:

Once connected, the commands used within jdb ( suspend , where all , and quit ) are the same as on OSX and linux.

Categories

Pages

• About this site


• Compressing data sent over a socket


• Dateformat and simpledateformat examples


• Deploying java apps on a virtual dedicated server


• Faster deep copies of java objects


• Faster jtextpane text insertion (part I)


• Faster jtextpane text insertion (part II)


• Fixing disappearing text selections when a menu is opened


• Gridbaglayout example: A simple form layout


• Java font problems under panther (mac OSX 10.3)


• JDB example: generating a thread dump


• Launching java webstart from the command line


• Linux X11 libraries for headless mode


• Low-memory deep copy technique for java objects


• Lucene in-memory text search example


• Profiling webstart apps with jprofiler on OSX


• Setting jtextpane font and color


• Squid corrupts jar files?


• String equality and interning

Copyright 2003-2016 - philip isenhour - all code samples may be freely used under the MIT open-source license

Jdb demo

Continue your winning streak with SPINDRIFT. Let’s meet again!

Enjoy POP POP FRUITY in the summer heat!

Experience the passion of waves, create new romantic summer vibes!

Come and PK dragon king and tiger king.

Are you still virtual mining? Come join MINER BABE to experience mining fun!

SPINDRIFT sequel－SPINDRIFT Ⅱ, continue your winning streak!

Passionate summer with fantastic waves! Catching the exciting waves in the summer hand in hand!

Enjoy POP POP FRUITY in the summer heat!

Dragon king and tiger king PK with all their might. DOUBLE WILDS－double strike. When obtaining three or more “combat badges,” players will be awarded with a free spin bonus.

Are you still virtual mining? Come join MINER BABE to experience mining fun! Mine the ore to multiply your rewards! Respin to mine your way to victory!

Saving money requires determination; seize the opportunity to get rich now! MONEYBAGS MAN will make you wealthy overnight!

Treasures springing up, ready to party all night long! JDB has launched an electro-music slot game “GOLDEN DISCO” . Enjoy the fabulous disco casino!

Pass on the NIUBI spirit and inherit the NIUBI soul! New edition of SUPER NIUBI DELUXE is here!

King of the jungle funkily attacks! JDB has launched an easy and simple single－line slot game of FUNKY KING KONG! Easily becoming wealthy by winning the 800X grand prize at home!

JDB's first elimination matching game of gambling! Come to check it out!

Chinese famous drama WINNING MASK Ⅰhas astonishingly been released! Haven't tried it yet?

WINNING MASK Ⅱ, combining the essence of traditional and classic culture elements with the typical chinese drama, face changing. Have you tried it yet?

“OPEN SESAME” , this mysterious code can open the gate leading to a treasure hiding cave!

“hidden in the deepest part of the cave, there lies an undiscovered mysterious treasure chest! ”

Golden rooster comes to announce great news with love.

“with mjolnir in hand, you will feel mighty!” hurry up and enjoy this thrilling game, MJOLNIR, with unstoppable matching gifts and hammer out the 2000X grand prize with all your strength!

“with a TREASURE BOWL at hand, you may win 1800 times of wealth.” the two stages of free spins game satisfy you to enjoy the fun of having endless wealth! Join the treasure bowl and it won’t be a dream to win abundant money every day.

“great signs that lead to good luck, great fortune and plenty of wealth all around for the future.” legends has it that pixius is a sign of wealth that will allow you to acquire every type of wealth. Playing FORTUNE TREASURE will bring you favorable fortunes and generate plenty of wealth!

Mythical legendary treasures lie underneath the ancient and mysterious egyptian pyramids! The royal treasures filled with fantasies that are worth fortunes awaiting to be discovered!

The journey for treasures is about to begin as I will become the king of pirates!

“long time ago, it is said that when an ancient animal arrives, more and more wealth will come to the. ”

“red dragon! White dragon! East wind. ” would you like to play a round of MAHJONG in your leisure time?

GO LAI FU has simple gameplay, an entertaining rhythm, and even more chances to bring wealth on its wheel. 1000X prizes are waiting for you to take them home!

Want to make money? Want to be rich? Want to get rich now? Get on your horse to get rich now!

In a mysterious oriental nation, legend says that there is a great treasure guarded by five dragons. Choose your guardian dragon and pray that he will magnanimously grant you his treasure!

When the most talented man of southern china, tang bohu, meets the talented lady, qiouxiang, what kind of sparkles will they make?

Tang bohu wearing his groom's outfit, and qiu xiang wearing her bridal gown, have become special wild re-spin symbols in this free game. Spin and spin again! Hitting the jackpot is no longer just a dream!

Happy new year! The god of fortune brings a big red envelope! Come to join NEW YEAR! We're giving out red envelopes by the bundle, so you can easily win the 1000X jackpot!

As the moon begins to shine, the golden dragon holds a pearl. You only need three pearls to play the game for free and experience its excitement, with a wide range of non-stop prizes for you to open and open again!

“A diamond can be forever, three diamonds can win 10 million!”

The dragon is in the sky, bringing prizes with every round, fortune with every pull, taking your wealth to greater heights!

FORMOSA BEAR, the white pattern with V－shaped on the bears' chest signalizes the great omen of victory.

Jdb demo

Finds and fixes bugs in java platform programs.

Synopsis

Jdb [options] [classname] [arguments]

Command-line options. See options.

Name of the main class to debug.

Arguments passed to the main() method of the class.

Description

The java debugger (JDB) is a simple command-line debugger for java classes. The jdb command and its options call the JDB. The jdb command demonstrates the java platform debugger architecture (JDBA) and provides inspection and debugging of a local or remote java virtual machine (JVM). See java platform debugger architecture (JDBA) at
http://docs.Oracle.Com/javase/8/docs/technotes/guides/jpda/index.Html

Start a JDB session

There are many ways to start a JDB session. The most frequently used way is to have JDB launch a new JVM with the main class of the application to be debugged. Do this by substituting the jdb command for the java command in the command line. For example, if your application's main class is myclass , then use the following command to debug it under JDB:

When started this way, the jdb command calls a second JVM with the specified parameters, loads the specified class, and stops the JVM before executing that class's first instruction.

Another way to use the jdb command is by attaching it to a JVM that is already running. Syntax for starting a JVM to which the jdb command attaches when the JVM is running is as follows. This loads in-process debugging libraries and specifies the kind of connection to be made.

You can then attach the jdb command to the JVM with the following command:

The myclass argument is not specified in the jdb command line in this case because the jdb command is connecting to an existing JVM instead of launching a new JVM.

There are many other ways to connect the debugger to a JVM, and all of them are supported by the jdb command. The java platform debugger architecture has additional documentation on these connection options.

Basic jdb commands

The following is a list of the basic jdb commands. The JDB supports other commands that you can list with the -help option.

The help or ? Commands display the list of recognized commands with a brief description.

After you start JDB and set breakpoints, you can use the run command to execute the debugged application. The run command is available only when the jdb command starts the debugged application as opposed to attaching to an existing JVM.

Continues execution of the debugged application after a breakpoint, exception, or step.

Displays java objects and primitive values. For variables or fields of primitive types, the actual value is printed. For objects, a short description is printed. See the dump command to find out how to get more information about an object.

Note: to display local variables, the containing class must have been compiled with the javac -g option.

The print command supports many simple java expressions including those with method invocations, for example:

For primitive values, the dump command is identical to the print command. For objects, the dump command prints the current value of each field defined in the object. Static and instance fields are included. The dump command supports the same set of expressions as the print command.

List the threads that are currently running. For each thread, its name and current status are printed and an index that can be used in other commands. In this example, the thread index is 4, the thread is an instance of java.Lang.Thread , the thread name is main , and it is currently running.

Select a thread to be the current thread. Many jdb commands are based on the setting of the current thread. The thread is specified with the thread index described in the threads command.

The where command with no arguments dumps the stack of the current thread. The where all command dumps the stack of all threads in the current thread group. The where threadindex command dumps the stack of the specified thread.

If the current thread is suspended either through an event such as a breakpoint or through the suspend command, then local variables and fields can be displayed with the print and dump commands. The up and down commands select which stack frame is the current stack frame.

Breakpoints

Breakpoints can be set in JDB at line numbers or at the first instruction of a method, for example:

The command stop at myclass:22 sets a breakpoint at the first instruction for line 22 of the source file containing myclass .

The command stop in java.Lang.String.Length sets a breakpoint at the beginning of the method java.Lang.String.Length .

The command stop in myclass. Uses to identify the static initialization code for myclass .

When a method is overloaded, you must also specify its argument types so that the proper method can be selected for a breakpoint. For example, myclass.Mymethod(int,java.Lang.String) or myclass.Mymethod() .

The clear command removes breakpoints using the following syntax: clear myclass:45 . Using the clear or stop command with no argument displays a list of all breakpoints currently set. The cont command continues execution.

Stepping

The step command advances execution to the next line whether it is in the current stack frame or a called method. The next command advances execution to the next line in the current stack frame.

Exceptions

When an exception occurs for which there is not a catch statement anywhere in the throwing thread's call stack, the JVM typically prints an exception trace and exits. When running under JDB, however, control returns to JDB at the offending throw. You can then use the jdb command to diagnose the cause of the exception.

Use the catch command to cause the debugged application to stop at other thrown exceptions, for example: catch java.Io.Filenotfoundexception or catch mypackage.Bigtroubleexception . Any exception that is an instance of the specified class or subclass stops the application at the point where it is thrown.

The ignore command negates the effect of an earlier catch command. The ignore command does not cause the debugged JVM to ignore specific exceptions, but only to ignore the debugger.

Options

When you use the jdb command instead of the java command on the command line, the jdb command accepts many of the same options as the java command, including -D , -classpath , and -X options. The following list contains additional options that are accepted by the jdb command.

Other options are supported to provide alternate mechanisms for connecting the debugger to the JVM it is to debug. For additional documentation about these connection alternatives, see java platform debugger architecture (JPDA) at
http://docs.Oracle.Com/javase/8/docs/technotes/guides/jpda/index.Html

Displays a help message.

-sourcepath dir1:dir2: . . .

Uses the specified path to search for source files in the specified path. If this option is not specified, then use the default path of dot (.).

Attaches the debugger to a running JVM with the default connection mechanism.

Waits for a running JVM to connect to the specified address with a standard connector.

Starts the debugged application immediately upon startup of JDB. The -launch option removes the need for the run command. The debugged application is launched and then stopped just before the initial application class is loaded. At that point, you can set any necessary breakpoints and use the cont command to continue execution.

List the connectors available in this JVM.

-connect connector-name:name1=value1

Connects to the target JVM with the named connector and listed argument values.

Prints information for debugging the jdb command.

Runs the application in the java hotspot VM client.

Runs the application in the java hotspot VM server.

Passes option to the JVM, where option is one of the options described on the reference page for the java application launcher. For example, -J-xms48m sets the startup memory to 48 MB. See java (1).

Options forwarded to the debugger process

Lists directories separated by colons in which to look for classes.

Jdb - the java debugger

Jdb helps you find and fix bugs in java language programs.

SYNOPSIS

DESCRIPTION

The java debugger, jdb, is a simple command-line debugger for java classes. It is a demonstration of the java platform debugger architecture that provides inspection and debugging of a local or remote java virtual machine.

Starting a jdb session

There are many ways to start a jdb session. The most frequently used way is to have jdb launch a new java virtual machine (VM) with the main class of the application to be debugged. This is done by substituting the command jdb for java in the command line. For example, if your application's main class is myclass, you use the following command to debug it under JDB:

When started this way, jdb invokes a second java VM with any specified parameters, loads the specified class, and stops the VM before executing that class's first instruction.

Another way to use jdb is by attaching it to a java VM that is already running. Syntax for starting a VM to which jdb will attach when the VM is running is as follows. This loads in-process debugging libraries and specifies the kind of connection to be made.

For example, the following command will run the myclass application, and allow jdb to connect to it at a later time.

You can then attach jdb to the VM with the following commmand:

Note that "myclass" is not specified in the jdb command line in this case because jdb is connecting to an existing VM instead of launching a new one.

There are many other ways to connect the debugger to a VM, and all of them are supported by jdb. The java platform debugger architecture has additional documentation on these connection options. For information on starting a J2SE 1.4.2 or early VM for use with jdb see the 1.4.2 documentation

Basic jdb commands

The following is a list of the basic jdb commands. The java debugger supports other commands which you can list using jdb's help command.

Help, or ? The most important jdb command, help displays the list of recognized commands with a brief description. Run after starting jdb, and setting any necessary breakpoints, you can use this command to start the execution the debugged application. This command is available only when jdb launches the debugged application (as opposed to attaching to an existing VM). Cont continues execution of the debugged application after a breakpoint, exception, or step. Print displays java objects and primitive values. For variables or fields of primitive types, the actual value is printed. For objects, a short description is printed. See the dump command below for getting more information about an object.

NOTE: to display local variables, the containing class must have been compiled with the javac -g option.

Print supports many simple java expressions including those with method invocations, for example:

• Print myclass.Mystaticfield


• Print myobj.Myinstancefield


• Print i + j + k(i, j, k are primities and either fields or local variables)


• Print myobj.Mymethod()(if mymethod returns a non-null)


• Print new java.Lang.String("hello").Length()

dump for primitive values, this command is identical to print. For objects, it prints the current value of each field defined in the object. Static and instance fields are included.

The dump command supports the same set of expressions as the print command. Threads list the threads that are currently running. For each thread, its name and current status are printed, as well as an index that can be used for other commands, for example: in this example, the thread index is 4, the thread is an instance of java.Lang.Thread, the thread name is "main", and it is currently running, thread select a thread to be the current thread. Many jdb commands are based on the setting of the current thread. The thread is specified with the thread index described in the threads command above. Where where with no arguments dumps the stack of the current thread. Where all dumps the stack of all threads in the current thread group. Where threadindex dumps the stack of the specified thread.

If the current thread is suspended (either through an event such as a breakpoint or through the suspend command), local variables and fields can be displayed with the print and dump commands. The up and down commands select which stack frame is current.

Breakpoints

Breakpoints can be set in jdb at line numbers or at the first instruction of a method, for example:

• Stop at myclass:22(sets a breakpoint at the first instruction for line 22 of the source file containing myclass)


• Stop in java.Lang.String.Length(sets a breakpoint at the beginnig of the method java.Lang.String.Length)


• Stop in myclass.( identifies the myclass constructor)


• Stop in myclass.( identifies the static initialization code for myclass)

If a method is overloaded, you must also specify its argument types so that the proper method can be selected for a breakpoint. For example, "myclass.Mymethod(int,java.Lang.String)", or "myclass.Mymethod()".

The clear command removes breakpoints using a syntax as in "clear myclass:45". Using the clear or command with no argument displays a list of all breakpoints currently set. The cont command continues execution.

Stepping

The step commands advances execution to the next line whether it is in the current stack frame or a called method. The next command advances execution to the next line in the current stack frame.

Exceptions

When an exception occurs for which there isn't a catch statement anywhere in the throwing thread's call stack, the VM normally prints an exception trace and exits. When running under jdb, however, control returns to jdb at the offending throw. You can then use jdb to diagnose the cause of the exception.

Use the catch command to cause the debugged application to stop at other thrown exceptions, for example: "catch java.Io.Filenotfoundexception" or "catch mypackage.Bigtroubleexception. Any exception which is an instance of the specifield class (or of a subclass) will stop the application at the point where it is thrown.

The ignore command negates the effect of a previous catch command.

NOTE: the ignore command does not cause the debugged VM to ignore specific exceptions, only the debugger.

Command line options

When you use jdb in place of the java application launcher on the command line, jdb accepts many of the same options as the java command, including -D, -classpath, and -X .

The following additional options are accepted by jdb:

-help displays a help message. -sourcepath uses the given path in searching for source files in the specified path. If this option is not specified, the default path of "." is used. -attach attaches the debugger to previously running VM using the default connection mechanism. -listen waits for a running VM to connect at the specified address using standard connector. -listenany waits for a running VM to connect at any available address using standard connector. -launch launches the debugged application immediately upon startup of jdb. This option removes the need for using the run command. The debuged application is launched and then stopped just before the initial application class is loaded. At that point you can set any necessary breakpoints and use the cont to continue execution. -listconnectors list the connectors available in this VM -connect : = . Connects to target VM using named connector with listed argument values. -dbgtrace [flags] prints info for debugging jdb. -tclient runs the application in the java hotspot(tm) VM (client). -tserver runs the application in the java hotspot(tm) VM (server). -Joption pass option to the java virtual machine used to run jdb. (options for the application java virtual machine are passed to the run command.) for example, -J-xms48m sets the startup memory to 48 megabytes.

Other options are supported for alternate mechanisms for connecting the debugger and the VM it is to debug. The java platform debugger architecture has additional documentation on these connection alternatives.

So, let's see, what we have: JDB - introduction - debugging is a technical procedure to find and remove bugs or defects in a program and get expected results. Debugging includes testing and monitoring. It is ve at jdb demo