Java ThreadPoolExecutor getMaximumPoolSize() Method

The getMaximumPoolSize() method of ThreadPoolExecutor class returns the maximum number of threads allowed.

Syntax

Parameters

No parameter is passed.

Return

The maximum number of threads allowed.

Throw

Does not throw the exception.

Example 1

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.lang.Thread;
public class ThreadPoolExecutorgetMaximumPoolSizeExample1   {
	
             public static void main(final String[] arguments) throws InterruptedException {
             ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
             System.out.println("MAXIMUM POOL SIZE BEFORE SUBMIT: "+ executor.getMaximumPoolSize());
             executor.submit(new Task());
             executor.submit(new Task());
             executor.shutdown();
             System.out.println(" POOL SIZE AFTER SUBMIT:"+ executor.getLargestPoolSize());
              }  

        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:

MAXIMUM POOL SIZE BEFORE SUBMIT: 2147483647
 POOL SIZE AFTER SUBMIT:2
Running Thread Name: pool-1-thread-1
Running Thread Name: pool-1-thread-2
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 ThreadPoolExecutorgetMaximumPoolSizeExample2     {
           public static void main(String[] args) {
                     Task45 task1 = new Task45("t1");
                     Task45 task2 = new Task45("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(" After submit largest pool size: "+ tExecutor.getLargestPoolSize());
                     tExecutor.shutdown(); // shutdown worker threads
                     System.out.println("Threads started, main ends\n");
                        }
              }

    class Task45 implements Runnable {
                 private final String threadName;
                 public Task45(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(Task45.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
 After submit largest pool size: 4
Threads started, main ends

Thread sleeping for 1000 i=0
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 :

Next TopicJava ThreadPoolExecutor

← prev next →