java jdb 调试

[hadoop@hadoop-01 ~]$ javac -help
Usage: javac <options> <source files>
where possible options include:
  -g                         Generate all debugging info
  -g:none                    Generate no debugging info
  -g:{lines,vars,source}     Generate only some debugging info
  -nowarn                    Generate no warnings
  -verbose                   Output messages about what the compiler is doing
  -deprecation               Output source locations where deprecated APIs are used
  -classpath <path>          Specify where to find user class files and annotation processors
  -cp <path>                 Specify where to find user class files and annotation processors
  -sourcepath <path>         Specify where to find input source files
  -bootclasspath <path>      Override location of bootstrap class files
  -extdirs <dirs>            Override location of installed extensions
  -endorseddirs <dirs>       Override location of endorsed standards path
  -proc:{none,only}          Control whether annotation processing and/or compilation is done.
  -processor <class1>[,<class2>,<class3>...] Names of the annotation processors to run; bypasses default discovery process
  -processorpath <path>      Specify where to find annotation processors
  -parameters                Generate metadata for reflection on method parameters
  -d <directory>             Specify where to place generated class files
  -s <directory>             Specify where to place generated source files
  -h <directory>             Specify where to place generated native header files
  -implicit:{none,class}     Specify whether or not to generate class files for implicitly referenced files
  -encoding <encoding>       Specify character encoding used by source files
  -source <release>          Provide source compatibility with specified release
  -target <release>          Generate class files for specific VM version
  -profile <profile>         Check that API used is available in the specified profile
  -version                   Version information
  -help                      Print a synopsis of standard options
  -Akey[=value]              Options to pass to annotation processors
  -X                         Print a synopsis of nonstandard options
  -J<flag>                   Pass <flag> directly to the runtime system
  -Werror                    Terminate compilation if warnings occur
  @<filename>                Read options and filenames from file

[hadoop@hadoop-01 ~]$ vi HelloJDB.java
public class HelloJDB {
        public static void main(String...args) {
                int i = 5;
                int j = 6;
                int sum = add(i, j);
                sum = 0;
                for (i = 0; i < 100; i++) {
                        sum += i;
                }
                System.out.println(sum);
        }
        public static int add(int augend, int addend) {
                int sum = augend + addend;
                return sum;
        }
}

[hadoop@hadoop-01 ~]$ javac -g HelloJDB.java
[hadoop@hadoop-01 ~]$ jdb -classpath .:HelloJDB
Initializing jdb ...
> help
** command list **
connectors                -- list available connectors and transports in this VM

run [class [args]]        -- start execution of application's main class

threads [threadgroup]     -- list threads
thread <thread id>        -- set default thread
suspend [thread id(s)]    -- suspend threads (default: all)
resume [thread id(s)]     -- resume threads (default: all)
where [<thread id> | all] -- dump a thread's stack
wherei [<thread id> | all]-- dump a thread's stack, with pc info
up [n frames]             -- move up a thread's stack
down [n frames]           -- move down a thread's stack
kill <thread id> <expr>   -- kill a thread with the given exception object
interrupt <thread id>     -- interrupt a thread

print <expr>              -- print value of expression
dump <expr>               -- print all object information
eval <expr>               -- evaluate expression (same as print)
set <lvalue> = <expr>     -- assign new value to field/variable/array element
locals                    -- print all local variables in current stack frame

classes                   -- list currently known classes
class <class id>          -- show details of named class
methods <class id>        -- list a class's methods
fields <class id>         -- list a class's fields

threadgroups              -- list threadgroups
threadgroup <name>        -- set current threadgroup

stop in <class id>.<method>[(argument_type,...)]
                          -- set a breakpoint in a method
stop at <class id>:<line> -- set a breakpoint at a line
clear <class id>.<method>[(argument_type,...)]
                          -- clear a breakpoint in a method
clear <class id>:<line>   -- clear a breakpoint at a line
clear                     -- list breakpoints
catch [uncaught|caught|all] <class id>|<class pattern>
                          -- break when specified exception occurs
ignore [uncaught|caught|all] <class id>|<class pattern>
                          -- cancel 'catch' for the specified exception
watch [access|all] <class id>.<field name>
                          -- watch access/modifications to a field
unwatch [access|all] <class id>.<field name>
                          -- discontinue watching access/modifications to a field
trace [go] methods [thread]
                          -- trace method entries and exits.
                          -- All threads are suspended unless 'go' is specified
trace [go] method exit | exits [thread]
                          -- trace the current method's exit, or all methods' exits
                          -- All threads are suspended unless 'go' is specified
untrace [methods]         -- stop tracing method entrys and/or exits
step                      -- execute current line
step up                   -- execute until the current method returns to its caller
stepi                     -- execute current instruction
next                      -- step one line (step OVER calls)
cont                      -- continue execution from breakpoint

list [line number|method] -- print source code
use (or sourcepath) [source file path]
                          -- display or change the source path
exclude [<class pattern>, ... | "none"]
                          -- do not report step or method events for specified classes
classpath                 -- print classpath info from target VM

monitor <command>         -- execute command each time the program stops
monitor                   -- list monitors
unmonitor <monitor#>      -- delete a monitor
read <filename>           -- read and execute a command file

lock <expr>               -- print lock info for an object
threadlocks [thread id]   -- print lock info for a thread

pop                       -- pop the stack through and including the current frame
reenter                   -- same as pop, but current frame is reentered
redefine <class id> <class file name>
                          -- redefine the code for a class

disablegc <expr>          -- prevent garbage collection of an object
enablegc <expr>           -- permit garbage collection of an object

!!                        -- repeat last command
<n> <command>             -- repeat command n times
# <command>               -- discard (no-op)
help (or ?)               -- list commands
version                   -- print version information
exit (or quit)            -- exit debugger

<class id>: a full class name with package qualifiers
<class pattern>: a class name with a leading or trailing wildcard ('*')
<thread id>: thread number as reported in the 'threads' command
<expr>: a Java(TM) Programming Language expression.
Most common syntax is supported.

Startup commands can be placed in either "jdb.ini" or ".jdbrc"
in user.home or user.dir
> stop in HelloJDB.main
Deferring breakpoint HelloJDB.main.
It will be set after the class is loaded.
> run
Main class and arguments must be specified
> run HelloJDB
run  HelloJDB
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
>
VM Started: Set deferred breakpoint HelloJDB.main

Breakpoint hit: "thread=main", HelloJDB.main(), line=3 bci=0
3               int i = 5;

main[1] locals
Method arguments:
args = instance of java.lang.String[0] (id=403)
Local variables:
main[1] step
>
Step completed: "thread=main", HelloJDB.main(), line=4 bci=2
4               int j = 6;

main[1] locals
Method arguments:
args = instance of java.lang.String[0] (id=403)
Local variables:
i = 5
main[1] step
>
Step completed: "thread=main", HelloJDB.main(), line=5 bci=5
5               int sum = add(i, j);

main[1] locals
Method arguments:
args = instance of java.lang.String[0] (id=403)
Local variables:
i = 5
j = 6
main[1] print i
 i = 5
main[1] print j
 j = 6
main[1] list
1    public class HelloJDB {
2       public static void main(String...args) {
3               int i = 5;
4               int j = 6;
5 =>            int sum = add(i, j);
6               sum = 0;
7               for (i = 0; i < 100; i++) {
8                       sum += i;
9               }
10              System.out.println(sum);
main[1] step
>
Step completed: "thread=main", HelloJDB.add(), line=13 bci=0
13              int sum = augend + addend;

main[1] list
9               }
10              System.out.println(sum);
11      }
12      public static int add(int augend, int addend) {
13 =>           int sum = augend + addend;
14              return sum;
15      }
16    }
main[1] step up
>
Step completed: "thread=main", HelloJDB.main(), line=5 bci=10
5               int sum = add(i, j);

main[1] list
1    public class HelloJDB {
2       public static void main(String...args) {
3               int i = 5;
4               int j = 6;
5 =>            int sum = add(i, j);
6               sum = 0;
7               for (i = 0; i < 100; i++) {
8                       sum += i;
9               }
10              System.out.println(sum);
main[1] step
>
Step completed: "thread=main", HelloJDB.main(), line=6 bci=11
6               sum = 0;

main[1] print sum
 sum = 11
main[1] step
>
Step completed: "thread=main", HelloJDB.main(), line=7 bci=13
7               for (i = 0; i < 100; i++) {

main[1] list
3               int i = 5;
4               int j = 6;
5               int sum = add(i, j);
6               sum = 0;
7 =>            for (i = 0; i < 100; i++) {
8                       sum += i;
9               }
10              System.out.println(sum);
11      }
12      public static int add(int augend, int addend) {
main[1] stop at HelloJDB:10
Set breakpoint HelloJDB:10
main[1] list
3               int i = 5;
4               int j = 6;
5               int sum = add(i, j);
6               sum = 0;
7 =>            for (i = 0; i < 100; i++) {
8                       sum += i;
9               }
10              System.out.println(sum);
11      }
12      public static int add(int augend, int addend) {
main[1] cont
>
Breakpoint hit: "thread=main", HelloJDB.main(), line=10 bci=31
10              System.out.println(sum);

main[1] list
6               sum = 0;
7               for (i = 0; i < 100; i++) {
8                       sum += i;
9               }
10 =>           System.out.println(sum);
11      }
12      public static int add(int augend, int addend) {
13              int sum = augend + addend;
14              return sum;
15      }
main[1] print sum
 sum = 4950
main[1] exit
4950
[hadoop@hadoop-01 ~]$ 

参照：https://www.cnblogs.com/rocedu/p/6371262.html