Java Executors defaultThreadFactory() Method

The Executors class in Java provides the defaultThreadFactory() method to create a default ThreadFactory. This guide will cover the usage of the defaultThreadFactory() method, explain how it works, and provide concise examples to demonstrate its functionality in real-world use cases.

Introduction

The Executors.defaultThreadFactory() method is used to create a default ThreadFactory that generates new threads. This factory creates threads with the same security settings, group, and priority as the calling thread, and the threads are created as non-daemon threads.

defaultThreadFactory Method Syntax

The syntax for the defaultThreadFactory method is as follows:

public static ThreadFactory defaultThreadFactory()

• The method does not take any parameters.
• The method returns a ThreadFactory that creates new threads.

Examples

Example 1: Using Default Thread Factory with ExecutorService

In this example, we use the default ThreadFactory with an ExecutorService to create and manage threads.

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

public class DefaultThreadFactoryExample {
    public static void main(String[] args) {
        // Create a default ThreadFactory
        ThreadFactory threadFactory = Executors.defaultThreadFactory();

        // Create an ExecutorService with the default ThreadFactory
        ExecutorService executor = Executors.newFixedThreadPool(2, threadFactory);

        // Submit tasks to the executor
        executor.submit(() -> System.out.println("Task 1 executed by: " + Thread.currentThread().getName()));
        executor.submit(() -> System.out.println("Task 2 executed by: " + Thread.currentThread().getName()));

        // Shutdown the executor
        executor.shutdown();
    }
}

Output:

Task 1 executed by: pool-1-thread-1
Task 2 executed by: pool-1-thread-2

Example 2: Customizing Thread Factory

In this example, we customize the default ThreadFactory to create threads with a custom naming pattern.

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;

public class CustomThreadFactoryExample {
    public static void main(String[] args) {
        // Create a custom ThreadFactory
        ThreadFactory customThreadFactory = new ThreadFactory() {
            private final AtomicInteger threadNumber = new AtomicInteger(1);
            private final ThreadFactory defaultFactory = Executors.defaultThreadFactory();

            @Override
            public Thread newThread(Runnable r) {
                Thread thread = defaultFactory.newThread(r);
                thread.setName("CustomThread-" + threadNumber.getAndIncrement());
                return thread;
            }
        };

        // Create an ExecutorService with the custom ThreadFactory
        ExecutorService executor = Executors.newFixedThreadPool(2, customThreadFactory);

        // Submit tasks to the executor
        executor.submit(() -> System.out.println("Task 1 executed by: " + Thread.currentThread().getName()));
        executor.submit(() -> System.out.println("Task 2 executed by: " + Thread.currentThread().getName()));

        // Shutdown the executor
        executor.shutdown();
    }
}

Output:

Task 1 executed by: CustomThread-1
Task 2 executed by: CustomThread-2

Example 3: Using Default Thread Factory with ScheduledExecutorService

In this example, we use the default ThreadFactory with a ScheduledExecutorService to schedule tasks.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorExample {
    public static void main(String[] args) {
        // Create a default ThreadFactory
        ThreadFactory threadFactory = Executors.defaultThreadFactory();

        // Create a ScheduledExecutorService with the default ThreadFactory
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2, threadFactory);

        // Schedule tasks
        executor.schedule(() -> System.out.println("Task 1 executed by: " + Thread.currentThread().getName()), 1, TimeUnit.SECONDS);
        executor.schedule(() -> System.out.println("Task 2 executed by: " + Thread.currentThread().getName()), 2, TimeUnit.SECONDS);

        // Shutdown the executor after a delay
        executor.schedule(() -> executor.shutdown(), 3, TimeUnit.SECONDS);
    }
}

Output:

Task 1 executed by: pool-1-thread-1
Task 2 executed by: pool-1-thread-2

Conclusion

The Executors.defaultThreadFactory() method in Java is used for creating a default ThreadFactory that generates new threads with standard settings. It can be used with various executor services to manage thread creation and execution.