Category:

Advanced

Java Singleton Design Pattern Tutorial

written by 75ypsaw71

A Singleton class in Java is a class that allows only one instance of itself to be created throughout the lifetime of the application.

The Singleton design pattern is useful when you need exactly one object to coordinate actions across the system, such as managing a database connection, logging, or controlling access to shared resources.

In this tutorial, we will explore different ways to implement a Singleton class in Java, with various code examples demonstrating the best practices.

Table of Contents
Toggle

Key Features of a Singleton Class:
1. Eager Initialization Singleton
2. Lazy Initialization Singleton
3. Thread-Safe Singleton (Synchronized)
4. Double-Checked Locking Singleton
5. Bill Pugh Singleton (Inner Static Helper Class)
6. Enum Singleton
7. Singleton with Reflection Safe
8. Singleton with Serialization Protection
Conclusion

Key Features of a Singleton Class:

Private Constructor: The constructor is made private to prevent direct instantiation from outside the class.
Static Instance: The class holds a static instance of itself.
Global Access: A public static method provides a global point of access to the instance.

1. Eager Initialization Singleton

In eager initialization, the instance of the Singleton class is created at the time of class loading. This is the simplest method to create a Singleton, but it may lead to resource wastage if the instance is never used.

Example:

public class EagerSingleton {
    // Static instance of the Singleton class, created eagerly
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    // Private constructor to prevent instantiation
    private EagerSingleton() {
        System.out.println("EagerSingleton instance created");
    }

    // Public method to provide access to the instance
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        EagerSingleton singleton = EagerSingleton.getInstance();
    }
}

Explanation:

The INSTANCE is created at class loading time.
The getInstance() method provides global access to the Singleton instance.

Output:

EagerSingleton instance created (printed only once).

2. Lazy Initialization Singleton

In lazy initialization, the instance is created only when it is needed, i.e., when getInstance() is called for the first time. This can save resources if the instance is never used.

Example:

public class LazySingleton {
    // Static instance of the Singleton class, not initialized initially
    private static LazySingleton instance;

    // Private constructor to prevent instantiation
    private LazySingleton() {
        System.out.println("LazySingleton instance created");
    }

    // Public method to provide access to the instance, creating it lazily
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        LazySingleton singleton = LazySingleton.getInstance();
    }
}

Explanation:

The instance is created lazily when getInstance() is first called.
The instance is created only if instance == null.

Output:
LazySingleton instance created.

3. Thread-Safe Singleton (Synchronized)

To make the Singleton thread-safe, we can synchronize the getInstance() method so that only one thread can execute it at a time. This prevents race conditions in multithreaded environments.

Example:

public class ThreadSafeSingleton {
    // Static instance of the Singleton class, not initialized initially
    private static ThreadSafeSingleton instance;

    // Private constructor to prevent instantiation
    private ThreadSafeSingleton() {
        System.out.println("ThreadSafeSingleton instance created");
    }

    // Synchronized method to ensure thread safety
    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        ThreadSafeSingleton singleton = ThreadSafeSingleton.getInstance();
    }
}

Explanation:

The synchronized keyword ensures that only one thread can create the instance.
This prevents multiple threads from creating multiple instances.

Output:
ThreadSafeSingleton instance created.

4. Double-Checked Locking Singleton

The double-checked locking technique reduces the overhead of synchronization by only synchronizing the block of code that creates the instance, rather than the entire method. This is more efficient than synchronizing the entire method.

Example:

public class DoubleCheckedLockingSingleton {
    // Static instance of the Singleton class, using volatile to ensure visibility across threads
    private static volatile DoubleCheckedLockingSingleton instance;

    // Private constructor to prevent instantiation
    private DoubleCheckedLockingSingleton() {
        System.out.println("DoubleCheckedLockingSingleton instance created");
    }

    // Double-checked locking for thread-safe and efficient Singleton
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        DoubleCheckedLockingSingleton singleton = DoubleCheckedLockingSingleton.getInstance();
    }
}

Explanation:

The volatile keyword ensures that the instance variable is read from the main memory, not from the thread's local cache.
The first if check prevents unnecessary synchronization, and the second if ensures that the instance is only created once.

Output:
DoubleCheckedLockingSingleton instance created.

5. Bill Pugh Singleton (Inner Static Helper Class)

This method is considered one of the best ways to implement a Singleton in Java. It takes advantage of Java's class loading mechanism to ensure that the Singleton is created only when needed, without the need for synchronization.

Example:

public class BillPughSingleton {
    // Private constructor to prevent instantiation
    private BillPughSingleton() {
        System.out.println("BillPughSingleton instance created");
    }

    // Inner static helper class responsible for holding the Singleton instance
    private static class SingletonHelper {
        // The Singleton instance is created when this class is loaded
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    // Public method to provide access to the Singleton instance
    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        BillPughSingleton singleton = BillPughSingleton.getInstance();
    }
}

Explanation:

The SingletonHelper class is not loaded until getInstance() is called, ensuring lazy initialization.
This approach is thread-safe without requiring synchronization.

Output:
BillPughSingleton instance created.

6. Enum Singleton

Using an enum to implement a Singleton is the most robust way, as it provides thread safety, serialization safety, and guarantees that only one instance will be created.

Example:

public enum EnumSingleton {
    INSTANCE;  // The single instance

    public void doSomething() {
        System.out.println("Enum Singleton is working!");
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        EnumSingleton singleton = EnumSingleton.INSTANCE;
        singleton.doSomething();
    }
}

Explanation:

The INSTANCE is the single instance of EnumSingleton.
Enum-based Singleton ensures that only one instance is created, even in multithreaded environments or when dealing with serialization.

Output:
Enum Singleton is working!.

7. Singleton with Reflection Safe

One of the drawbacks of using traditional Singleton methods is that reflection can break the Singleton pattern by allowing multiple instances to be created. To prevent this, you can add a check in the constructor.

Example:

public class ReflectionSafeSingleton {
    // Static instance of the Singleton class
    private static ReflectionSafeSingleton instance;

    // Private constructor to prevent instantiation
    private ReflectionSafeSingleton() {
        // Prevent reflection from breaking Singleton
        if (instance != null) {
            throw new RuntimeException("Cannot create instance using reflection");
        }
        System.out.println("ReflectionSafeSingleton instance created");
    }

    // Public method to provide access to the instance
    public static ReflectionSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ReflectionSafeSingleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        ReflectionSafeSingleton singleton = ReflectionSafeSingleton.getInstance();
    }
}

Explanation:

The constructor checks if an instance already exists, and if it does, it throws an exception to prevent reflection-based instantiation.

Output:
ReflectionSafeSingleton instance created.

8. Singleton with Serialization Protection

When a Singleton class implements Serializable, it can create new instances during deserialization. To prevent this, override the readResolve() method to return the same instance.

Example:

import java.io.Serializable;

public class SerializedSingleton implements Serializable {
    private static final long serialVersionUID = 1L;

    // Static instance of the Singleton class
    private static final SerializedSingleton INSTANCE = new SerializedSingleton();

    // Private constructor to prevent instantiation
    private SerializedSingleton() {
        System.out.println("SerializedSingleton instance created");
    }

    // Public method to provide access to the instance
    public static SerializedSingleton getInstance() {
        return INSTANCE;
    }

    // readResolve method to prevent creating a new instance during deserialization
    protected Object readResolve() {
        return getInstance();
    }
}

public class Main {
    public static void main(String[] args) {
        // Accessing the Singleton instance
        SerializedSingleton singleton = SerializedSingleton.getInstance();
    }
}

Explanation:

The readResolve() method ensures that the same instance is returned during deserialization.

Output:
SerializedSingleton instance created.

Conclusion

The Singleton design pattern ensures that only one instance of a class is created and provides global access to that instance. In Java, there are several ways to implement the Singleton pattern:

Eager Initialization: The instance is created when the class is loaded.
Lazy Initialization: The instance is created when it is first accessed.
Thread-Safe Singleton: The synchronized keyword ensures only one thread creates the instance.
Double-Checked Locking: Minimizes the cost of synchronization with a double check.
Bill Pugh Singleton: Inner static class provides a lazy-loaded thread-safe Singleton.
Enum Singleton: The most robust and straightforward implementation.
Reflection and Serialization Safe: Methods to protect against breaking the Singleton pattern with reflection or serialization.

By choosing the appropriate method for your application's needs, you can implement Singleton classes effectively in Java.

October 9, 2024 0 comment

Advanced

Java Threads Tutorial: Creating a Thread

written by 75ypsaw71

Java provides built-in support for multithreading, allowing you to execute multiple threads simultaneously to achieve concurrent execution.

Threads in Java are lightweight processes that allow your program to perform multiple tasks at the same time, which can significantly improve the performance of your application.

This tutorial will guide you through different ways of creating and managing threads in Java, with examples for each method.

Table of Contents

What is a Thread?

A thread is a small unit of a process that executes independently. Java provides two ways to create a thread:

By extending the Thread class.
By implementing the Runnable interface.

1. Creating a Thread by Extending the Thread Class

The Thread class itself provides methods to create and manage threads. By extending the Thread class, we can create our own thread.

Steps:

Extend the Thread class.
Override the run() method, which contains the code that the thread will execute.
Create an instance of the class and call the start() method to begin execution of the thread.

Example:

// Creating a thread by extending the Thread class
class MyThread extends Thread {
    @Override
    public void run() {
        // Code that will be executed by the thread
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        // Creating a new thread
        MyThread thread = new MyThread();
        thread.start();  // Start the thread
    }
}

Explanation:

We extend the Thread class and override the run() method to define the task for the thread.
The start() method is called to begin the thread execution, which internally calls the run() method.
Output will show the thread name:

Thread is running: Thread-0

2. Creating a Thread by Implementing the Runnable Interface

Another way to create a thread in Java is by implementing the Runnable interface.

This approach is more flexible since it allows the class to extend another class, while still enabling multithreading.

Steps:
Implement the Runnable interface in your class.
Override the run() method.
Create an instance of Thread by passing a Runnable object, and call start().

Example:

// Creating a thread by implementing the Runnable interface
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // Code that will be executed by the thread
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        // Creating a Runnable object
        MyRunnable runnable = new MyRunnable();
        
        // Creating a thread with the Runnable object
        Thread thread = new Thread(runnable);
        thread.start();  // Start the thread
    }
}

Explanation:

We implement the Runnable interface and override the run() method.
The Thread object is created by passing the Runnable object, and start() is called to execute the thread.
Output will show the thread name:

Thread is running: Thread-0

3. Using an Anonymous Class to Create a Thread

You can also create a thread using an anonymous class that implements the Runnable interface, which avoids explicitly defining a new class.

Example:

public class AnonymousClassThread {
    public static void main(String[] args) {
        // Creating a thread using an anonymous class
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running: " + Thread.currentThread().getName());
            }
        });
        
        thread.start();  // Start the thread
    }
}

Explanation:

An anonymous class implementing Runnable is passed to the Thread constructor.
This is a compact way to create threads if you don’t want to create a separate class.

Output:

Thread is running: Thread-0

4. Creating a Thread using Lambda Expressions (Java 8+)

From Java 8 onwards, you can use lambda expressions to simplify thread creation, especially when using functional interfaces like Runnable.

Example:

public class LambdaThread {
    public static void main(String[] args) {
        // Creating a thread using a lambda expression
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running using Lambda: " + Thread.currentThread().getName());
        });

        thread.start();  // Start the thread
    }
}

Explanation:

Lambda expressions provide a concise way to create threads by eliminating the need for boilerplate code.

Output:

Thread is running using Lambda: Thread-0

5. Passing Parameters to Threads

You can pass parameters to threads by using the constructor of the class that implements Runnable or extends Thread.

Example:

// A class that implements Runnable and takes a parameter
class MyRunnableWithParams implements Runnable {
    private String name;

    public MyRunnableWithParams(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("Thread " + name + " is running");
    }
}

public class ThreadWithParams {
    public static void main(String[] args) {
        // Passing parameters to threads
        MyRunnableWithParams runnable1 = new MyRunnableWithParams("Thread 1");
        MyRunnableWithParams runnable2 = new MyRunnableWithParams("Thread 2");

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();
    }
}

Explanation:

Parameters are passed to the Runnable object through the constructor.

Output:

Thread Thread 1 is running
Thread Thread 2 is running

6. Getting and Setting Thread Names

Each thread has a name, and you can set or get the name of a thread using getName() and setName() methods.

Example:

public class ThreadNameExample {
    public static void main(String[] args) {
        // Creating a thread and setting its name
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running: " + Thread.currentThread().getName());
        });

        thread.setName("MyCustomThread");
        thread.start();  // Start the thread

        // Getting the main thread name
        System.out.println("Main thread name: " + Thread.currentThread().getName());
    }
}

Explanation:

We use setName() to set a custom name for the thread.

Output:

Thread is running: MyCustomThread
Main thread name: main

7. Using join() to Wait for Threads to Finish

The join() method allows one thread to wait for another thread to finish its execution before continuing.

Example:

public class JoinThreadExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is running");
            try {
                Thread.sleep(2000);  // Simulate some work with sleep
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1 has finished");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 is running");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 has finished");
        });

        thread1.start();
        thread2.start();

        try {
            // Wait for both threads to finish
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All threads have finished");
    }
}

Explanation:

The join() method ensures that the main thread waits for thread1 and thread2 to finish before printing the final message.

Output:

Thread 1 is running
Thread 2 is running
Thread 2 has finished
Thread 1 has finished
All threads have finished

8. Using sleep() to Pause Execution

The sleep() method pauses the execution of a thread for a specified number of milliseconds.

Example:

public class SleepThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread started");
            try {
                Thread.sleep(3000);  // Pauses the thread for 3 seconds
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread resumed after sleep");
        });

        thread.start();
    }
}

Explanation:

The sleep() method pauses the thread for 3 seconds before resuming.

Output:

Thread started
Thread resumed after sleep

9. Handling InterruptedException

The InterruptedException is thrown when a thread is interrupted while it is sleeping, waiting, or otherwise paused.

Example:

public class InterruptedExceptionExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread is sleeping...");
                Thread.sleep(5000);  // Pauses for 5 seconds
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted!");
            }
        });

        thread.start();

        // Interrupt the thread after 2 seconds
        try {
            Thread.sleep(2000);
            thread.interrupt();  // Interrupt the thread
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Explanation:

The interrupt() method interrupts a thread, which causes it to throw an InterruptedException if it is sleeping or waiting.

Output:

Thread is sleeping...
Thread was interrupted!

Conclusion

Threads in Java allow concurrent execution of tasks, improving the performance and responsiveness of applications.

There are two main ways to create a thread: by extending the Thread class or by implementing the Runnable interface. Both approaches offer flexibility depending on the design needs of your application.

By understanding how to create, manage, and control thread behavior (e.g., using join(), sleep(), and interrupt()), you can effectively use multithreading to build efficient Java applications.

October 9, 2024 0 comment

Newer Posts

Older Posts