如何在PDB中暂停所有线程？解决多线程Python调试干扰问题

Problem Description #

When debugging a multi-threaded Python program with the standard PDB debugger, only the thread that hits the breakpoint stops—all other threads keep running. This can create annoying distractions during debugging, as shown in this example:

test.py

from threading import Thread
from time import sleep

def thread1():
    while True:
        sleep(1)
        print("hello")

def thread2():
    breakpoint()

Thread(target=thread1).start()
Thread(target=thread2).start()

When running this script with python test.py, the debugging session gets flooded with output from thread1:

$ python test.py
--Return--
> /.../test.py(12)thread2()->None
-> breakpoint()
(Pdb)
hello
hello
hello
hello
...

We know PyCharm's debugger supports pausing all threads, so is there a way to replicate this behavior in PDB?

Answer #

The standard library PDB doesn’t have a built-in feature to automatically pause all threads—its default behavior is exactly what you’re seeing: only the thread triggering the breakpoint pauses, while others continue executing. But there are two reliable ways to fix this:

1. Use an enhanced debugger (recommended)

Third-party debuggers built on top of PDB add multi-thread support (plus other handy features). Two popular options are:

• pdbpp: A drop-in replacement for PDB that automatically pauses all threads when a breakpoint is hit. Install it with pip install pdbpp, then run your script with python -m pdbpp test.py.
• ipdb: IPython’s debugger, which also supports pausing all threads. Install via pip install ipdb, then launch with python -m ipdb test.py.

These tools handle thread management behind the scenes, so you don’t need to modify your code at all.

2. Manually control thread execution in your code

If you want to stick with the standard PDB, you can add explicit synchronization logic to pause other threads when hitting a breakpoint. Here’s how to adjust your example:

from threading import Thread, Event, enumerate
from time import sleep

# Global event to control thread execution
pause_event = Event()
pause_event.set()  # Start with threads un-paused

def thread1():
    while True:
        pause_event.wait()  # Pause if the event is cleared
        sleep(1)
        print("hello")

def thread2():
    global pause_event
    # Pause all other threads before hitting the breakpoint
    pause_event.clear()
    breakpoint()
    # Resume threads once debugging is done
    pause_event.set()

Thread(target=thread1).start()
Thread(target=thread2).start()

Now when thread2 hits the breakpoint, thread1 will pause at pause_event.wait() and stop spamming output. Once you type c (continue) in PDB, thread1 will resume running.

内容的提问来源于stack exchange，提问作者Noë Rubinstein