Introduction

Pry is great for dropping into an interactive session, but it does not provide a clean global "pause every other thread" switch for arbitrary Ruby code. If one thread enters binding.pry, other threads may continue running unless your program or debugger explicitly coordinates them.

What Pry Does and Does Not Do

binding.pry pauses the current thread at that binding and opens an interactive console. It does not automatically freeze the rest of the process.

1require "pry"
2
3Thread.new do
4  loop do
5    puts "worker still running"
6    sleep 1
7  end
8end
9
10binding.pry

In that example, the worker thread may continue printing while you are inside Pry, depending on runtime behavior and scheduling.

There Is No Universal Safe "Stop All Threads" Command

Ruby threads may hold locks, wait on IO, or coordinate through shared state. Arbitrarily suspending all of them is risky because:

• you can freeze the program in a misleading intermediate state,
• you may deadlock around mutexes,
• some threads may be doing work you actually need to observe.

That is why Pry does not present a polished command that simply suspends every other thread safely.

Better Options for Debugging

For multithreaded debugging, these approaches are usually safer:

• use a real debugger designed for stepping and thread inspection,
• add synchronization points in the code,
• pause worker activity cooperatively with flags, mutexes, or condition variables.

A cooperative pause pattern looks like this:

1require "thread"
2
3pause_mutex = Mutex.new
4pause_cv = ConditionVariable.new
5paused = false
6
7worker = Thread.new do
8  loop do
9    pause_mutex.synchronize do
10      pause_cv.wait(pause_mutex) while paused
11    end
12
13    puts "working"
14    sleep 1
15  end
16end
17
18# later in debugging code:
19pause_mutex.synchronize { paused = true }
20# inspect state
21pause_mutex.synchronize do
22  paused = false
23  pause_cv.broadcast
24end

That kind of design is much more reliable than trying to freeze random threads from the outside.

Inspect Threads From Pry

Even if you cannot safely stop all threads, you can still inspect them from Pry.

Thread.list.each do |t|
  puts "#{t.object_id} #{t.status}"
end

That gives you visibility into which threads exist and whether they are running, sleeping, or aborted.

Last-Resort Manual Control

If you absolutely need to interfere with thread execution during debugging, you can experiment with thread APIs, but this is not something to use casually in production logic.

1Thread.list.each do |t|
2  next if t == Thread.current || t == Thread.main
3  puts "thread #{t.object_id}: #{t.status}"
4end

Inspection is usually safer than trying to kill or suspend them. Once you start terminating threads, you may destroy the very state you were trying to debug.

For that reason alone, thread inspection is often the better first move.

Common Pitfalls

• Expecting Pry alone to pause every other Ruby thread automatically.
• Trying to kill worker threads during debugging and then trusting the resulting program state.
• Ignoring mutexes and shared-state consistency when forcing thread behavior.
• Using ad hoc thread stopping instead of cooperative pause points.
• Assuming multithreaded debugging is easy in Pry just because binding.pry stops the current thread.

Summary

• Pry pauses the current thread, not the entire process.
• There is no universal safe Pry command that cleanly stops every other thread.
• Cooperative pause logic is usually safer than forceful thread interference.
• 'Thread.list is useful for inspection even when full suspension is not practical.'
• For serious multithreaded debugging, use stronger debugger support or explicit synchronization hooks.