Java ThreadPoolExecutor getQueue() Method

The getQueue() method of ThreadPoolExecutor returns the task queue used by this executor. Access to the task queue is intended primarily for debugging and monitoring. This queue may be in active use. Retrieving the task queue does not prevent queued tasks from executing.

Syntax

Parameters

No parameter is passed.

Return

the task queue

Throw

Does not throw exception.

Example 1

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.lang.Thread;
public class ThreadPoolExecutorgetQueueExample1  {
	
        public static void main(final String[] arguments) throws InterruptedException {
               ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
               executor.submit(new Task());
               System.out.println("POOL SIZE : "+ executor.getPoolSize());
               executor.submit(new Task());
               executor.shutdown();
               System.out.println("get Queue:"+ executor.getQueue());
             }  

      static class Task implements Runnable {
      @Override
      public void run() {
          try {
              Long duration = (long) (Math.random() * 5);
              System.out.println("Running Thread Name: " + Thread.currentThread().getName());
              TimeUnit.SECONDS.sleep(duration);
              System.out.println("Completed Thread Name: " +Thread.currentThread().getName());
            } catch (InterruptedException e) {
              }
                   }
                                   }
}

Test it Now

Output:

POOL SIZE : 1
get Queue:[]
Running Thread Name: pool-1-thread-2
Running Thread Name: pool-1-thread-1
Completed Thread Name: pool-1-thread-2
Completed Thread Name: pool-1-thread-1

Example 2

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.lang.Thread;
import java.util.logging.Level;
import java.util.logging.Logger;


public class ThreadPoolExecutorgetQueueExample2 {
             public static void main(String[] args) {
               Work22 task1 = new Work22("t1");
               Work22 task2 = new Work22("t2");
               System.out.println("Starting threads");
               ThreadPoolExecutor tExecutor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
               System.out.println("  Maximum pool size: "+ tExecutor.getMaximumPoolSize());
               tExecutor.submit(task1); tExecutor.submit(task2); 
               tExecutor.execute(task1); // start task1
               tExecutor.execute(task2); // start task2    
               System.out.println(" get Queue: "+ tExecutor.getQueue());
               tExecutor.shutdown(); // shutdown worker threads
               System.out.println("Threads started, main ends\n");
              }
        }

class Work22 implements Runnable {
      private final String threadName;
              public Work22(String threadName) {
                      this.threadName = threadName;
                   }
  
  @Override
     public void run() {
            for(int i=0 ; i<=10;i++)
              {
                 if(i<5)
                     {
                       try {
                            System.out.println("Thread sleeping for 1000 i=" +i);
                            Thread.sleep(1000);
                          } catch (InterruptedException ex) {
                               Logger.getLogger(Work22.class.getName()).log(Level.SEVERE, null, ex);
                        }
                     }
                else{
                      System.out.println(" now  i > 5 :");
                       break;
                   }
       }
}
}

Test it Now

Output:

Starting threads
  Maximum pool size: 2147483647
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
 get Queue: []
Threads started, main ends

Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=0
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=1
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=2
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=3
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :Thread sleeping for 1000 i=4
Thread sleeping for 1000 i=4
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :
 now  i > 5 :

Next TopicJava ThreadPoolExecutor

← prev next →