IntelliJ Thread Debug

Question

Does IntelliJ IDEA provide thread-debugging? That is - Netbeans allows you to debug multiple threads, and halting at those breakpoints (automatically). However all I seem to be getting in IntelliJ is "thread dumping", which seems to be an analysis that is manual, and a snapshot taken when I clicked 'Thread Dump'.

Is there something I'm missing? I have google'd and not found sufficient information to assist.

Answer 1

I think you can. I have suspended threads via breakpoints by setting the suspend policy. This will suspend the thread that is executing this piece of code. If you have multiple thread then I would think they would carry on.

To quote the suspend policy

• Item Description
• All : When the breakpoint is hit, all threads are suspended
• Thread : When the breakpoint is hit, the thread where the breakpoint is hit is suspended.
• None: No thread is suspended.

Answer 2

You have a nice Threads view available.

Press the little gearwheel and you will see all active threads.

And on each breakpoint you can set the Suspend Policy. You can either make the Thread alternative the default for all breakpoints or you can set them individually on each breakpoint.

Answer 3

For me the problem with not accessing thread still occcurs. I set up brakepoints to all. And put brakepoints inside calling methods. What I noticed is that the method in new thread is beeing accessed when i call run() but not start(). Just wondering why, AFAIK the start() method should call run(). Nevertheless, the output from thread occurs even I call .start(), but never access it.

Answer 4

For me the issue was that there seems to be a race condition with resuming threads after breakpoints and evaluating breakpoints in IntelliJ.

My short-term work around was to not set Breakpoints right before I spawn a thread. If I don't do this the first few Breakpoints in the run() or call() are missed.

Answer 5

I think the problem you have is that the child threads are being closed sooner than you expected because the main thread(the test itself) reaches to the end.

Remember that when you do a Thread.start() an asynchronous call starts, then if you are running your tests using Junit the execution will continue after this call until the end of the test, and as soon as it reaches to the end, it shutdowns the threads you started inside it.

Therefore, if you have something like:

01. import org.junit.Assert;
02. import org.junit.Test;
03. public class ThreadTest {
04.     static boolean didIGetIt = false;
05.     @Test
06.     public void testThread() {
07.         Thread myThread = new Thread(new Runnable() {
08.             @Override
09.             public void run() {
10.                 System.out.println("I am an asynchronous task");
11.                 System.out.println("and JUnit won't wait for me to finish my job!");
12.                 didIGetIt = true;
13.             }
14.         });
15.         myThread.start();
16.         Assert.assertTrue(didIGetIt);
17.     }
18. }

It will execute the Assert before the code inside the run() leading to a fail test.

But if you add a simple sleep you could stop the main thread and debug and do what you need before the main thread stops.

01. import org.junit.Assert;
02. import org.junit.Test;
03. public class ThreadTest {
04.     static boolean didIGetIt = false;
05.     @Test
06.     public void testThread() throws InterruptedException {
07.         Thread myThread = new Thread(new Runnable() {
08.             @Override
09.             public void run() {
10.                 System.out.println("I am an asynchronous task");
11.                 System.out.println("and JUnit won't wait for me to finish my job!");
12.                 didIGetIt = true;
13.             }
14.         });
15.         myThread.start();
16.         System.out.println("Let's wait for child threads to finish");
17.         Thread.sleep(5000);
18.         Assert.assertTrue(didIGetIt);
19.     }
20. }

Surely there are better ways to do it, but the Thread.sleep may be what you are looking for.

Hope it may help somebody!