Page 1 of 7
Home Whiteboard Online Compilers Practice Articles AI Assistant
Chapters Categories
SQL HTML CSS Javascript Python Java C C++ PHP Scala C#
Java - Singleton Class
Java Singleton Design Pattern
Singleton pattern is one of the simplest design patterns in Java. This type of design
pattern comes under creational pattern as this pattern provides one of the best ways to
create an object.
Java Singleton Class
This pattern involves a single class which is responsible to create an object while making
sure that only single object gets created. This class provides a way to access its only
object which can be accessed directly without need to instantiate the object of the class.
Since there is only one Singleton instance, any instance fields of a Singleton will occur
only once per class, just like static fields. Singletons often control access to resources,
such as database connections or sockets.
For example, if you have a license for only one connection for your database or your
JDBC driver has trouble with multithreading, the Singleton makes sure that only one
connection is made or that only one thread can access the connection at a time.
Advantages of Singleton Design Pattern
Singleton design pattern saves memory because only one object instance is created and
it also provides global access to its instance.
Use of Singleton Design Pattern
The singleton design pattern is used when you want to create such a class that has only
one instance. It is mainly used in multithreading to create multi-threaded and database-
related applications.
Page 2 of 7
Some of the designs where singleton design pattern is used:
To create logger classes
To create configuration management-related classes
To create classes related to database connection pooling
To create a class for the caching mechanism
Java Singleton Class/Design Pattern: Examples
Example 1
The easiest implementation consists of a private constructor and a field to hold its result,
and a static accessor method with a name like getInstance().
The private field can be assigned from within a static initializer block or, more simply,
using an initializer. The getInstance() method (which must be public) then simply
returns this instance −
Open Compiler
package com.tutorialspoint;
class Singleton {
private static Singleton singleton = new Singleton( );
/* A private Constructor prevents any other
* class from instantiating.
*/
private Singleton() { }
/* Static 'instance' method */
public static Singleton getInstance( ) {
return singleton;
}
/* Other methods protected by singleton-ness */
protected void demoMethod( ) {
System.out.println("demoMethod for singleton");
}
Page 3 of 7
}
public class Tester {
public static void main(String[] args) {
Singleton tmp = Singleton.getInstance( );
tmp.demoMethod( );
}
}
If you compile and execute the above program, you will get the following result −
Output
demoMethod for singleton
Example 2
Following implementation shows a classic Singleton design pattern. In this example, the
ClassicSingleton class maintains a static reference to the lone singleton instance and
returns that reference from the static getInstance() method.
Here, ClassicSingleton class employs a technique known as lazy instantiation to create
the singleton; as a result, the singleton instance is not created until the getInstance()
method is called for the first time. This technique ensures that singleton instances are
created only when needed.
Open Compiler
package com.tutorialspoint;
class ClassicSingleton {
private static ClassicSingleton instance = null;
private ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static ClassicSingleton getInstance() {
if(instance == null) {
instance = new ClassicSingleton();
}
Page 4 of 7
return instance;
}
protected void demoMethod( ) {
System.out.println("demoMethod for singleton");
}
}
public class Tester {
public static void main(String[] args) {
ClassicSingleton tmp = ClassicSingleton.getInstance( );
tmp.demoMethod( );
}
}
If you compile and execute the above program, you will get the following result −
Output
demoMethod for singleton
Example 3
Following implementation shows a threadsafe Singleton object creation. In this example,
the ClassicSingleton class maintains a static reference to the lone singleton instance
and returns that reference from the static getInstance() method which we've made
threadsafe using synchronized keyword.
Open Compiler
class ClassicSingleton {
private static ClassicSingleton instance = null;
private ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static synchronized ClassicSingleton getInstance() {
if(instance == null) {
instance = new ClassicSingleton();
Page 5 of 7
}
return instance;
}
protected void demoMethod( ) {
System.out.println("demoMethod for singleton");
}
}
public class Tester {
public static void main(String[] args) {
ClassicSingleton tmp = ClassicSingleton.getInstance( );
tmp.demoMethod( );
}
}
If you compile and execute the above program, you will get the following result −
Output
demoMethod for singleton
TOP TUTORIALS
Python Tutorial
Java Tutorial
C++ Tutorial
C Programming Tutorial
C# Tutorial
PHP Tutorial
R Tutorial
HTML Tutorial
CSS Tutorial
JavaScript Tutorial
SQL Tutorial
TRENDING TECHNOLOGIES
Page 6 of 7
Cloud Computing Tutorial
Amazon Web Services Tutorial
Microsoft Azure Tutorial
Git Tutorial
Ethical Hacking Tutorial
Docker Tutorial
Kubernetes Tutorial
DSA Tutorial
Spring Boot Tutorial
SDLC Tutorial
Unix Tutorial
CERTIFICATIONS
Business Analytics Certification
Java & Spring Boot Advanced Certification
Data Science Advanced Certification
Cloud Computing And DevOps
Advanced Certification In Business Analytics
Artificial Intelligence And Machine Learning
DevOps Certification
Game Development Certification
Front-End Developer Certification
AWS Certification Training
Python Programming Certification
COMPILERS & EDITORS
Online Java Compiler
Online Python Compiler
Online Go Compiler
Online C Compiler
Online C++ Compiler
Online C# Compiler
Online PHP Compiler
Online MATLAB Compiler
Online Bash Terminal
Online SQL Compiler
Page 7 of 7
Online Html Editor
ABOUT US | OUR TEAM | CAREERS | JOBS | CONTACT US | TERMS OF USE |
PRIVACY POLICY | REFUND POLICY | COOKIES POLICY | FAQ'S
Tutorials Point is a leading Ed Tech company striving to provide the best learning material on
technical and non-technical subjects.
© Copyright 2025. All Rights Reserved.
