newFixedThreadPool Example In Java

 newFixedThreadPool is the method of Executors class. It is use to create fixed size thread pool.

If you are new in executor fromwork please visit previous article ExecutorService and Thread Pools in java

Java Code Ecample:

package com.javaiq.in;

public class Task implements Runnable {

	private String name;

	public Task(String name) {
		super();
		this.name = name;
	}

	@Override
	public void run() {
		System.out.println("Starting " + name);
		// creating 6 task
		for (int i = 0; i <= 5; i++) {
			System.out.println("Executing " + name + " with " + Thread.currentThread().getName() + " ###### " + i);
		}
		System.out.println("Ending " + name);
	}
}

package com.javaiq.in;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {

	public static void main(String args[]) {
		// creating thread pool of size 2
		ExecutorService es = Executors.newFixedThreadPool(2);

		for (int i = 0; i <= 5; i++) {
			Task task = new Task("Task " + i);
			es.submit(task);
		}
		es.shutdown();
	}
}

Output : In the above example we have created 6 task and using newFixedThreadPool to create thread pool of size 2. 

Starting Task 0
Executing Task 0 with pool-1-thread-1 ###### 0
Executing Task 0 with pool-1-thread-1 ###### 1
Executing Task 0 with pool-1-thread-1 ###### 2
Executing Task 0 with pool-1-thread-1 ###### 3
Executing Task 0 with pool-1-thread-1 ###### 4
Executing Task 0 with pool-1-thread-1 ###### 5
Ending Task 0
Starting Task 2
Executing Task 2 with pool-1-thread-1 ###### 0
Executing Task 2 with pool-1-thread-1 ###### 1
Executing Task 2 with pool-1-thread-1 ###### 2
Executing Task 2 with pool-1-thread-1 ###### 3
Executing Task 2 with pool-1-thread-1 ###### 4
Executing Task 2 with pool-1-thread-1 ###### 5
Ending Task 2
Starting Task 3
Executing Task 3 with pool-1-thread-1 ###### 0
Executing Task 3 with pool-1-thread-1 ###### 1
Executing Task 3 with pool-1-thread-1 ###### 2
Executing Task 3 with pool-1-thread-1 ###### 3
Executing Task 3 with pool-1-thread-1 ###### 4
Executing Task 3 with pool-1-thread-1 ###### 5
Ending Task 3
Starting Task 4
Executing Task 4 with pool-1-thread-1 ###### 0
Executing Task 4 with pool-1-thread-1 ###### 1
Executing Task 4 with pool-1-thread-1 ###### 2
Executing Task 4 with pool-1-thread-1 ###### 3
Executing Task 4 with pool-1-thread-1 ###### 4
Executing Task 4 with pool-1-thread-1 ###### 5
Ending Task 4
Starting Task 5
Executing Task 5 with pool-1-thread-1 ###### 0
Executing Task 5 with pool-1-thread-1 ###### 1
Executing Task 5 with pool-1-thread-1 ###### 2
Executing Task 5 with pool-1-thread-1 ###### 3
Executing Task 5 with pool-1-thread-1 ###### 4
Executing Task 5 with pool-1-thread-1 ###### 5
Ending Task 5
Starting Task 1
Executing Task 1 with pool-1-thread-2 ###### 0
Executing Task 1 with pool-1-thread-2 ###### 1
Executing Task 1 with pool-1-thread-2 ###### 2
Executing Task 1 with pool-1-thread-2 ###### 3
Executing Task 1 with pool-1-thread-2 ###### 4
Executing Task 1 with pool-1-thread-2 ###### 5
Ending Task 1

ExecutorService and Thread Pools in java

Thread Pools :  Java Thread pool is a pool of threads (a group of fixed-size threads is created using LinkedBlockingQueue) means a collection of worker threads, it represents a group of worker threads it will reused to execute number of task. A thread pool helps to improve performance by reducing the number of threads needed and managing their lifecycle.That are waiting for the job and reused many times. A thread from the thread pool is pulled out and assigned a job by the service provider. Essentially, threads are kept in the thread pool until they're needed, after which they execute the task and return the pool to be reused later. 

Executor : Executor is an interface.

void shutdown() : Initiates an orderly shutdown, it will just tell the executor service that it can't accept new tasks but previously submitted tasks are executed.

List<Runnable> shutdownNow() : Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

execute() : The execute() method is defined in the Executor interface. it cannot return anything because's return type is void. it accept only Runnable task. it is used to submit a task to the Executor framework for asynchronous execution. 

submit() : The submit() method is defined in the ExecutorService interface. it can return the result of computation because it has a return type of Future object. it accept both Callable and Runnable. it is used to submit a task to the Executor framework for asynchronous execution. ExecutorService interface is sub-interface of Executor interface.

public interface Executor

ExecutorService : ExecutorService is sub-interface of Executor interface.

public interface ExecutorService extends Executor

ScheduledExecutorService  : ScheduledExecutorService is sub-interface of ExecutorService

public interface ScheduledExecutorService extends ExecutorService

Executors : Executors is a class.

Below are the methods and inner class defined in Executors class.

public static ExecutorService newFixedThreadPool(int nThreads) : This is used to Creates a thread pool of fixed size that will be reuse to execute task using shared unbounded queue.The threads will exist  in the pool until it is explicitly shutdown.They will wait in the queue until a thread is available. If any thread terminates due to a failure during execution prior to shutdown, a new one will take its place if needed to execute subsequent tasks.

For example if we have 1000 task and we have create thtead pool of size 50 than 50 task has taken in queue. a new one will take once existing thread is completed or terminated due to a failure during execution prior to shutdown. newFixedThreadPool Example In Java

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

public static ExecutorService newWorkStealingPool(int parallelism) : newWorkStealingPool was introduced  in Java 8, a new type of thread pool as newWorkStealingPool(). Creates a work-stealing thread pool using all available processors as its target parallelism level.

• newWorkStealingPool is an abstraction of ForkJoinPool.commonPool. Only the difference is Executors.newWorkStealingPool creates a pool in asynchronous mode and ForkJoinPool.commonPool doesn't.
• Bydefault it creates a work-stealing thread pool using all available processors as its target parallelism level. 
• Like ForkJoinPools, newWorkStealingPools Creates a thread pool that maintains enough threads to support the given parallelism level, and may use multiple queues to reduce contention.
• The actual number of threads may grow and shrink dynamically.
• ForkJoinPool.commonPool uses a last-in, first-out (LIFO) queue configuration, whereas Executors.newWorkStealingPool uses first-in, first-out approach (FIFO).
• A work-stealing pool makes no guarantees about the order in which submitted tasks are executed.
• Parallel level is the processors currently available on the machine.
• Runtime.getRuntime().availableProcessors() – This is the number of processors available to the JVM.
• It is based on work-stealing principle (work-stealing algorithm) : Work stealing is a scheduling strategy where worker threads that have finished their own tasks can steal pending tasks from other threads. 

/**
     * Creates a thread pool that maintains enough threads to support
     * the given parallelism level, and may use multiple queues to
     * reduce contention. The parallelism level corresponds to the
     * maximum number of threads actively engaged in, or available to
     * engage in, task processing. The actual number of threads may
     * grow and shrink dynamically. A work-stealing pool makes no
     * guarantees about the order in which submitted tasks are
     * executed.
     *
     * @param parallelism the targeted parallelism level
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code parallelism <= 0}
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

    /**
     * Creates a work-stealing thread pool using all
     * {@link Runtime#availableProcessors available processors}
     * as its target parallelism level.
     * @return the newly created thread pool
     * @see #newWorkStealingPool(int)
     * @since 1.8
     */
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

public static ExecutorService newWorkStealingPool(int parallelism)

public static ExecutorService newSingleThreadExecutor()

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

public static ExecutorService newCachedThreadPool()

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

public static ScheduledExecutorService newSingleThreadScheduledExecutor()

public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

public static ExecutorService unconfigurableExecutorService(ExecutorService executor)

public static ScheduledExecutorService   unconfigurableScheduledExecutorService(ScheduledExecutorService executor)

public static ThreadFactory defaultThreadFactory()

public static ThreadFactory privilegedThreadFactory()

static class DelegatedExecutorService extends AbstractExecutorService : This is static inner class in Excetutors class. A wrapper class that exposes only the ExecutorService methods of an ExecutorService implementation.

static class FinalizableDelegatedExecutorService extends DelegatedExecutorService : This is static inner class in Excetutors class.

static class DelegatedScheduledExecutorService extends DelegatedExecutorService implements ScheduledExecutorService  : This is static inner class in Excetutors class. A wrapper class that exposes only the ScheduledExecutorService  methods of a ScheduledExecutorService implementation.

newsinglethreadexecutor vs newfixedthreadpool

Q- Difference between Executors.newFixedThreadPool(1) and Executors.newSingleThreadExecutor()

newFixedThreadPool

/**
    * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

newSingleThreadExecutor

/**  
 * Unlike the otherwise equivalent
     * <tt>newFixedThreadPool(1)</tt> the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

Related Tutorials

• Lock Interface In Concurrency API
• Lock In Java Example
• StampedLock With Examples
  
• Differences between Lock and Synchronized block
• Method And Block Synchronization In Java Example
• How To Create Custom Lock
• Fair Lock In Java Example
• Synchronization Vs Lock in java
  
• Thread Pool - ThreadPoolExecutor Example
  
• How To Create Custom Thread Pool
  
• How ConcurrentHashMap Works Internally
  
• newsinglethreadexecutor vs newfixedthreadpool
  
• Future Vs Completablefuture
  
• ExecutorService vs ExecutorCompletionService in Java
  
• Callable Interface Example
  
• CompletableFuture
  
• ExecutorCompletionService
  
• Method And Block Synchronization
  
• ConcurrentHashMap
  
• Differences Between Submit and Execute methods
  
• Difference Between Callable and Runnable Interface in Java

ExecutorService vs ExecutorCompletionService in Java

comming soon..

Related Tutorials

• Lock Interface In Concurrency API
• Lock In Java Example
• StampedLock With Examples
  
• Differences between Lock and Synchronized block
• Method And Block Synchronization In Java Example
• How To Create Custom Lock
• Fair Lock In Java Example
• Synchronization Vs Lock in java
  
• Thread Pool - ThreadPoolExecutor Example
  
• How To Create Custom Thread Pool
  
• How ConcurrentHashMap Works Internally
  
• newsinglethreadexecutor vs newfixedthreadpool
  
• Future Vs Completablefuture
  
• ExecutorService vs ExecutorCompletionService in Java
  
• Callable Interface Example
  
• CompletableFuture
  
• ExecutorCompletionService
  
• Method And Block Synchronization
  
• ConcurrentHashMap
  
• Differences Between Submit and Execute methods
  
• Difference Between Callable and Runnable Interface in Java