Next: Thread-Specific Breakpoints, Previous: Non-Stop Mode, Up: Thread Stops

#### 5.5.3 Background Execution

gdb's execution commands have two variants: the normal foreground (synchronous) behavior, and a background (asynchronous) behavior. In foreground execution, gdb waits for the program to report that some thread has stopped before prompting for another command. In background execution, gdb immediately gives a command prompt so that you can issue other commands while your program runs.

You need to explicitly enable asynchronous mode before you can use background execution commands. You can use these commands to manipulate the asynchronous mode setting:

`set target-async on`
  Enable asynchronous mode.
`set target-async off`
  Disable asynchronous mode.
`show target-async`
  Show the current target-async setting.

If the target doesn't support async mode, gdb issues an error message if you attempt to use the background execution commands.

To specify background execution, add a `&` to the command. For example, the background form of the `continue` command is `continue&`, or just `c&`. The execution commands that accept background execution are:

`run`
  See Starting your Program.
`attach`
  See Debugging an Already-running Process.
`step`
  See step.
`stepi`
  See stepi.
`next`
  See next.
`nexti`
  See nexti.
`continue`
  See continue.
`finish`
  See finish.
`until`
  See until.

Background execution is especially useful in conjunction with non-stop mode for debugging programs with multiple threads; see Non-Stop Mode. However, you can also use these commands in the normal all-stop mode with the restriction that you cannot issue another execution command until the previous one finishes. Examples of commands that are valid in all-stop mode while the program is running include `help` and `info break`.

You can interrupt your program while it is running in the background by using the `interrupt` command.

`interrupt`
`interrupt -a`
  Suspend execution of the running program. In all-stop mode, `interrupt` stops the whole process, but in non-stop mode, it stops only the current thread. To stop the whole program in non-stop mode, use `interrupt -a`.