Website Technology Profiler

{
  "PageContent": "<h3>Bits, Bytes and Brains | A Learning Journey – Coding Adventures</h3>What is a Singleton Design PatternSometimes it’s important for some classes to have exactly one instance. There are many objects we only need one instance of them and if we, instantiate more than one, we’ll run into all sorts of problems like incorrect program behavior, overuse of resources, or inconsistent results.There are only two points in the definition of a singleton design pattern,There should be only one instance allowed for a class andWe should allow global point of access to that single instance.From the definition, it seems to be a very simple design pattern but when it comes toimplementation, it comes with a lot of implementation concerns.Explanation of the patternWith the Singleton pattern, you define a private constructor in the class, which ensures that no one can create a new instance of the class from outside. You also define a public method called “getInstance” that returns the single instance of the class. The first time the method is called, it creates a new instance of the class. Any subsequent calls to the method return the same instance that was created the first time. In this way, you ensure that there is only one instance of the class.The Singleton pattern can be implemented in various ways, but it is essential to ensure that only one instance of the class is created, and that it is accessible from anywhere in the code. To achieve this, it is common to use lazy initialization, where the instance is created only when it is first needed. In summary, the Singleton pattern can be useful for creating shared resources in a system where it is important to maintain a single instance and ensure that it is accessible from anywhere in the code. It can also be used to control the instantiation of a class, ensuring that it is only created once, and to provide a single point of access to the instance.Why Lazy InitializationLazy initialization will be beneficial when we want to delay the initialization until it is notneeded, because if we use eager initialization and if initialization fails there is no chanceto get the instance further. While in lazy initialization we may get it in second chance. In Lazy initialization we will not get instance until we call getInstance () method while ineager initialization it creates instance at the time of class loading.How to implement Singleton patternpackage com.rndayala.designpatterns.singleton;\r\n\r\n// Author : Raghunath Dayala\r\n\r\n/* Singleton is a design pattern that restricts a class to have ONLY one instance, \r\n * with a global point of access to it.\r\n * Useful when you want to limit the number of instances of a class that can exist in the system.\r\n * This can be useful in situations  where you want to maintain a single instance of a class \r\n * to represent a shared resource, such as a  logging service, database connection or a configuration manager.\r\n * Ref : Check my Kindle library\r\n */\r\n\r\npublic class Singleton {\r\n\t// private static variable\r\n\tprivate static Singleton instance = null;\r\n\t\r\n\t// a private constructor that ensures that it cannot be instantiated directly from outside the class.\r\n\tprivate Singleton() {\r\n\t\tSystem.out.println(\"Creating Singleton class object..\");\r\n\t}\r\n\t\r\n\t// public static method called getInstance is provided, \r\n\t// which returns the  single instance of the class.  \r\n\t// The first time the getInstance is invoked, it creates and returns the object.\r\n\t// Any subsequent calls returns the same instance created the first time.\r\n\tpublic static Singleton getInstance() {\r\n\t\tif (instance == null) {\r\n\t\t\tinstance = new Singleton();\r\n\t\t}\r\n\t\treturn instance;\r\n\t}\r\n}\r\n\r\n/* Problems :\r\n * 1. the above implementation is not thread safe.\r\n * 2. We can still be able to create new objects using Reflection.\r\n * 3. We can be able to create new objects using Cloning.\r\n * 4. When we do serialization/de-serialization, we get new objects.\r\n*/In above example, the Singleton class has a private constructor that ensures that it cannot be instantiated directly. Instead, a public static method called getInstance is provided, which returns the single instance of the class.The first time the getInstance method is called, it creates a new instance of the Singleton class by calling the private constructor. Subsequent calls to getInstance return the same instance that was created the first time.Multi-threaded Singleton implementationSingleton will work properly in multithreaded environment only if eager instantiation has been done because in this case instance creation will happen at the time of class loading only. But for Lazy instantiation we will have to take care of multiple things. If we want to delay the instantiation because of cost, we use to go with lazy.Simple Implementation :package com.rndayala.designpatterns.singleton;\r\n\r\n/**\r\n * Singleton in multi-threaded environments.\r\n * the behavior of Singleton instance when two threads are \r\n * getting executed by comparing their hash code values.\r\n * \r\n * The following code works only in Java 8.\r\n * @author rndayala\r\n */\r\n\r\nimport java.util.concurrent.ExecutorService;\r\nimport java.util.concurrent.Executors;\r\n\r\npublic class SingletonT {\r\n\t\r\n\tprivate static SingletonT instance = null; // lazy initialization\r\n\t\r\n\tprivate SingletonT() {\r\n\t\tSystem.out.println(\"Creating..\");\r\n\t}\r\n\t\r\n\t// When you run the above program many times you will notice that in multithreaded environment,\r\n\t// sometimes Singleton principle works, but sometimes it violates.\r\n\r\n\tpublic static SingletonT getInstance() {\r\n\t\tif (instance == null) {\r\n\t\t\tinstance = new SingletonT();\r\n\t\t}\r\n\t\treturn instance;\r\n\t}\r\n\r\n\r\n\r\n\tstatic void useSingleton() {\r\n\t\tSingletonT singleton = SingletonT.getInstance();\r\n\t\tprint(\"Singleton\", singleton);\r\n\t}\r\n\t\r\n\tstatic void print(String name, SingletonT obj) {\r\n\t\tSystem.out.println(String.format(\"Object : %s, hashcode : %d\", name, obj.hashCode()));\r\n\t}\r\n\t\r\n\tpublic static void main(String[] args) {\r\n\t\tExecutorService service = Executors.newFixedThreadPool(2);\r\n\t\tservice.submit(SingletonT::useSingleton); // Object : Singleton, hashcode : 918401706\r\n\t\tservice.submit(SingletonT::useSingleton); // Object : Singleton, hashcode : 918401706\r\n\t\tservice.shutdown();\r\n\t}\r\n\r\n}\r\n\r\n/* observations :\r\n * When you run the above program many times you will notice that in multithreaded environment,\r\n * sometimes Singleton principle works but sometimes it violates.\r\n * Fix : After applying synchronized keyword in the getInstance () method, the program will execute \r\n * properly without any issue but in Java.\r\n*/When you run the above program many times you will notice that in multithreaded environment, sometimes Singleton principle works, but sometimes it violates. Therefore we need to synchronize the getInstance () method as shown below :\t// When you run the above program many times you will notice that in multithreaded environment,\r\n\t// sometimes Singleton principle works, but sometimes it violates.\r\n\t// Fix : add synchronized keyword to the getInstance() method\r\n\r\n\tpublic static synchronized SingletonT getInstance() {\r\n\t\tif (instance == null) {\r\n\t\t\tinstance = new SingletonT();\r\n\t\t}\r\n\t\treturn instance;\r\n\t}After applying synchronized keyword in the getInstance () method the program will execute properly without any issue.Double Checked Locking Instead of  synchronizing whole method we can synchronize only the block of code which is affected while creating instance to escape the extra overhead as below :\t// Don't synchronize getInstance() method completely.\r\n\t// Synchronize only the block of code which is affected while creating instance.\r\n\tpublic static SingletonT getInstance() {\r\n\t\tif (instance == null) {\r\n\t\t\tsynchronized (SingletonT.class) {\r\n\t\t\t\tinstance = new SingletonT();\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn instance;\r\n\t}From the above code we have narrowed down the scope of synchronization for performance reasons. But the above code can cause issues due to thread switching. So to make sure no other thread has already acquired the lock we will apply one more check after acquiring the lock as shown below. This method is called Double Checked Locking.\t// Don't synchronize getInstance() method completely.\r\n\t// Synchronize only the block of code which is affected while creating instance.\r\n\tpublic static SingletonT getInstance() {\r\n\t\tif (instance == null) {\r\n\t\t\tsynchronized (SingletonT.class) {\r\n\t\t\t\t// double checked locking\r\n\t\t\t\tif (instance == null) {\r\n\t\t\t\t\tinstance = new SingletonT();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn instance;\r\n\t}Sometimes double checked locking also breaks the Principle of Singleton. It may return an instance in half-initialized state.To address this situation use volatile keyword at the time of instance declaration. Value of volatile variable will be published only when the change completes. Change to writeoperation happens before read operation in volatile variable. In short all threads will see the same value of variable.private static volatile SingletonT instance = null; // lazy initializationReflection – Singleton implementation violation ? How to Fix ?In Java, you can violate the Singleton pattern’s intended behavior using reflection.Reflection allows you to access and modify the private constructors and fields of a class, which can lead to the creation of multiple instances of the Singleton class, thus violating the pattern.Here’s an example of how the Singleton pattern can be violated using reflection in Java:import java.lang.reflect.Constructor;\r\n\r\npublic class Singleton {\r\n\r\n    private static Singleton instance;\r\n\r\n    private Singleton() {\r\n        // Private constructor\r\n    }\r\n\r\n    public static Singleton getInstance() {\r\n        if (instance == null) {\r\n            instance = new Singleton();\r\n        }\r\n        return instance;\r\n    }\r\n\r\n    // Other methods and fields...\r\n}\r\n\r\npublic class Main {\r\n\r\n    public static void main(String[] args) {\r\n        Singleton singleton1 = Singleton.getInstance();\r\n        Singleton singleton2 = null;\r\n\r\n        try {\r\n            // Using reflection to access the private constructor\r\n            Constructor&lt;Singleton&gt; constructor \r\n                              = Singleton.class.getDeclaredConstructor();\r\n            constructor.setAccessible(true);\r\n            singleton2 = constructor.newInstance();\r\n        } catch (Exception e) {\r\n            e.printStackTrace();\r\n        }\r\n\r\n        System.out.println(singleton1); // Output: Singleton@hashcode1\r\n        System.out.println(singleton2); // Output: Singleton@hashcode2\r\n    }\r\n}\r\nIn the example above, we try to access the private constructor of the Singleton class using reflection and create a new instance. As a result, singleton2 is not the same instance as singleton1, and we have violated the Singleton pattern’s intent.To protect against this kind of reflection-based Singleton pattern violation, you can modify the Singleton class to throw an exception if someone tries to create a new instance using reflection:public class Singleton {\r\n\r\n    private static Singleton instance;\r\n\r\n    private Singleton() {\r\n        if (instance != null) {\r\n            throw new RuntimeException(\"Use getInstance() method to get the single instance.\");\r\n        }\r\n    }\r\n\r\n    public static Singleton getInstance() {\r\n        if (instance == null) {\r\n            instance = new Singleton();\r\n        }\r\n        return instance;\r\n    }\r\n\r\n    // Other methods and fields...\r\n}\r\nBy adding the check inside the private constructor, any attempt to create a new instance through reflection will result in an exception, preserving the Singleton pattern’s integrity. However, it’s essential to be cautious when using reflection and design patterns together, as it can lead to unexpected behavior and undermine the patterns’ intended benefits.Clone – Singleton implementation violation ? How to Fix ?If we try to make instance by cloning it, the generated hash code of clonedcopy doesn’t match with the actual object so it also violates the Singleton principle of having a single instance.Here’s an example to illustrate the issue:public class Singleton implements Cloneable {\r\n\r\n    private static Singleton instance;\r\n\r\n    private Singleton() {\r\n        // Private constructor\r\n    }\r\n\r\n    public static Singleton getInstance() {\r\n        if (instance == null) {\r\n            instance = new Singleton();\r\n        }\r\n        return instance;\r\n    }\r\n\r\n    @Override\r\n    protected Object clone() throws CloneNotSupportedException {\r\n        return super.clone();\r\n    }\r\n\r\n    // Other methods and fields...\r\n}\r\n\r\npublic class Main {\r\n\r\n    public static void main(String[] args) {\r\n        Singleton singleton1 = Singleton.getInstance();\r\n        Singleton singleton2 = null;\r\n\r\n        try {\r\n            // Cloning the singleton object\r\n            singleton2 = (Singleton) singleton1.clone();\r\n        } catch (CloneNotSupportedException e) {\r\n            e.printStackTrace();\r\n        }\r\n\r\n        System.out.println(singleton1); // Obj: singleton1, hashcode: 366712642\r\n        System.out.println(singleton2); // Obj: clone, hashcode: 1442407170\r\n    }\r\n}\r\nIn this example, we implement the Cloneableinterface in the Singleton class, and we override the clone() method to call the super.clone() method. The generated hash code of cloned copy doesn’t match with the actual object so it also violates the Singleton principle.To address this issue, you may consider throwing an exception in the clone() method to prevent cloning altogether:public class Singleton implements Cloneable {\r\n\r\n    // Singleton implementation...\r\n\r\n    @Override\r\n    protected Object clone() throws CloneNotSupportedException {\r\n        throw new CloneNotSupportedException(\"Cloning of Singleton objects is not allowed.\");\r\n    }\r\n\r\n    // Other methods and fields...\r\n}\r\nBy throwing a CloneNotSupportedException, you explicitly prohibit cloning of the Singleton objects and maintain the integrity of the Singleton pattern. However, it’s important to note that the use of Cloneable and clone() method can be controversial in Java, and it is generally recommended to avoid using them in favor of other approaches like copy constructors or factory methods for object duplication.How to fix: Throw CloneNotSupportedException from the clone () method if someonetries to make other instance of it.Bill Pugh method – Singleton ImplementationThe Bill Pugh Singleton pattern, also known as the Initialization-on-demand Holder Idiom, is an improvement over the traditional Singleton pattern. It provides a simpler and more thread-safe way to implement a Singleton in Java without the need for explicit synchronization. This pattern takes advantage of the Java class-loading mechanism to ensure that the Singleton instance is created lazily and safely when the class is loaded.We use inner static class approach in this implementation. The inner static class encapsulates the Singleton instance, and its instantiation logic is taken care of by the JVM, reducing the need for explicit synchronization or volatile variables.Bill Pugh implementation – thread safe, no need of explicit synchronization or volatile variable. The inner static class shields the Singleton instance from being created through reflection, as the constructor remains private.Here’s the implementation of the Bill Pugh Singleton pattern:public class Singleton {\r\n\r\n    // Private constructor to prevent instantiation from other classes\r\n    private Singleton() {\r\n        // Initialization code (if any) goes here\r\n    }\r\n\r\n    // Inner static helper class responsible for holding the Singleton instance\r\n    private static class SingletonHolder {\r\n        // The Singleton instance is created when the class is loaded\r\n        private static final Singleton INSTANCE = new Singleton();\r\n    }\r\n\r\n    // Public static method to get the Singleton instance\r\n    public static Singleton getInstance() {\r\n        return SingletonHolder.INSTANCE;\r\n    }\r\n\r\n    // Other methods and fields...\r\n}\r\nIn this implementation, the Singleton class has a private constructor to prevent direct instantiation. The Singleton instance is stored as a static field within a nested static class called SingletonHolder. The INSTANCE field is initialized during the class-loading phase, which is guaranteed to be thread-safe by the Java Virtual Machine.When getInstance() is called, it returns the Singleton instance held by the SingletonHolder, ensuring that only one instance is created throughout the application’s lifecycle. Here’s how you can use the Bill Pugh Singleton pattern:public class Main {\r\n\r\n    public static void main(String[] args) {\r\n        // Get the Singleton instance\r\n        Singleton singleton1 = Singleton.getInstance();\r\n        Singleton singleton2 = Singleton.getInstance();\r\n\r\n        // Both instances are the same\r\n        System.out.println(singleton1 == singleton2); // Output: true\r\n    }\r\n}\r\nThis approach provides better performance and avoids unnecessary synchronization overhead because the Singleton is initialized lazily and only when needed.Nowadays, this Bill Pugh method is widely used and considered a best practice for creating Singleton instances.enum implementation of Singleton patternIn Java, you can implement the Singleton pattern using an enum. Enums in Java are implicitly singleton by design, as they only allow a fixed set of predefined instances, and there can be no more than one instance of each enum constant. This property makes enums a natural fit for implementing a singleton.Joshua Bloch suggests the use of Enum to implement Singleton design pattern as Java ensures that any enum value is instantiated only once in a Java program. Since Java Enum values are globally accessible, so is the singleton. The drawback is that the enum type is somewhat inflexible; for example, it does not allow lazy initialization.Here’s how you can implement the Singleton pattern using an enum :public enum SingletonEnum {\r\n    INSTANCE;\r\n\r\n    // Any additional fields or methods for the Singleton can be added here\r\n    // ...\r\n\r\n    // Example method\r\n    public void doSomething() {\r\n        // Implement functionality here\r\n    }\r\n}\r\nIn this implementation, SingletonEnum is an enum that contains a single instance called INSTANCE. When the SingletonEnum class is loaded, the INSTANCE constant is initialized, and it remains the only instance throughout the application’s lifecycle.In the context of implementing the Singleton pattern using an enum, the INSTANCE is a single constant instance of the enum type. In Java, enum constants are implicitly static and final, which means they can only be created once during the class loading and cannot be modified afterward. As a result, an enum with a single constant effectively serves as a singleton.INSTANCE represents the sole instance of the SingletonEnum class. The enum constant name (INSTANCE in this case) can be any valid Java identifier, but by convention, INSTANCE is commonly used to signify that it represents the single instance of the singleton.You can use the SingletonEnum instance like this:public class Main {\r\n\r\n    public static void main(String[] args) {\r\n        SingletonEnum singleton1 = SingletonEnum.INSTANCE;\r\n        SingletonEnum singleton2 = SingletonEnum.INSTANCE;\r\n\r\n        // Both instances are the same\r\n        System.out.println(singleton1 == singleton2); // Output: true\r\n\r\n        // Call methods on the Singleton instance\r\n        singleton1.doSomething();\r\n    }\r\n}\r\nAs enum constants are inherently thread-safe and guaranteed to be initialized only once, using an enum for the Singleton pattern eliminates the need for explicit synchronization and ensures a simple, efficient, and safe singleton implementation in Java.As with any enum, the SingletonEnum’s instance is implicitly thread-safe and immune to issues related to reflection or serialization, making this approach one of the simplest and most effective ways to implement a thread-safe Singleton pattern in Java.Enum Singleton doesn’t violate principle of Singleton in any case described above.",
  "Url": "https://rndayala.com",
  "IpAddress": "192.0.78.162",
  "ReverseDns": null,
  "Asn": null,
  "Http2": false,
  "Http3": false,
  "ResponseTimeMs": 1426,
  "StatusCode": 200,
  "ServerHeaders": [
    "nginx"
  ],
  "Ssl": {
    "Issuer": "CN=E7, O=Let's Encrypt, C=US",
    "Subject": "CN=tls.automattic.com",
    "NotBefore": "2026-01-05T17:04:14-08:00",
    "NotAfter": "2026-04-05T18:04:13-07:00",
    "SubjectAltNames": [
      "DNS Name=abunadhseeds.ca",
      "DNS Name=articlesportfolio.game.blog",
      "DNS Name=bezzycay.art",
      "DNS Name=dotsonfala.music.blog",
      "DNS Name=fit2perform.health.blog",
      "DNS Name=garethsspace.com",
      "DNS Name=hannelesofia.com",
      "DNS Name=hollygayley.org",
      "DNS Name=hungryginger.com",
      "DNS Name=idealhelsinki.com",
      "DNS Name=ispartaortodonti.net",
      "DNS Name=optimizedbd.health.blog",
      "DNS Name=politicssportsbar.com",
      "DNS Name=presentalmostperfect.com",
      "DNS Name=psychedelaine.be",
      "DNS Name=researcher.code.blog",
      "DNS Name=riadnourtravel.com",
      "DNS Name=rndayala.com",
      "DNS Name=schoolops.com",
      "DNS Name=seowriter.marketing",
      "DNS Name=shevideoreviews.movie.blog",
      "DNS Name=shigatsetravels-tibet.com",
      "DNS Name=shopmn.blog",
      "DNS Name=sports520.game.blog",
      "DNS Name=tls.automattic.com",
      "DNS Name=tuireisecenterkempten.code.blog",
      "DNS Name=wellthisisforyou.health.blog",
      "DNS Name=www.935.fashion.blog",
      "DNS Name=www.abunadhseeds.ca",
      "DNS Name=www.articlesportfolio.game.blog",
      "DNS Name=www.catarinalab.com",
      "DNS Name=www.fit2perform.health.blog",
      "DNS Name=www.garethsspace.com",
      "DNS Name=www.hannelesofia.com",
      "DNS Name=www.hollygayley.org",
      "DNS Name=www.hungryginger.com",
      "DNS Name=www.iamcandicemonita.com",
      "DNS Name=www.idealhelsinki.com",
      "DNS Name=www.optimizedbd.health.blog",
      "DNS Name=www.politicssportsbar.com",
      "DNS Name=www.preservingfoodathome.com",
      "DNS Name=www.psychedelaine.be",
      "DNS Name=www.researcher.code.blog",
      "DNS Name=www.schoolops.com",
      "DNS Name=www.shevideoreviews.movie.blog",
      "DNS Name=www.shigatsetravels-tibet.com",
      "DNS Name=www.shopmn.blog",
      "DNS Name=www.shytea.co",
      "DNS Name=www.sports520.game.blog",
      "DNS Name=www.tuireisecenterkempten.code.blog",
      "DNS Name=www.wellthisisforyou.health.blog"
    ],
    "Hsts": true,
    "Ciphers": [],
    "Protocol": "Tls13",
    "DaysUntilExpiry": 66
  },
  "Cdns": [],
  "HostingHints": [],
  "Cms": [
    "WordPress",
    "WordPress (robots.txt)"
  ],
  "Frameworks": [
    "React",
    "jQuery"
  ],
  "JsLibraries": [],
  "Analytics": [
    "Google Analytics GA4"
  ],
  "AdsAndMarketing": [],
  "PaymentGateways": [],
  "EcommerceHints": [
    "Magento",
    "PrestaShop"
  ],
  "SocialSignals": [],
  "MediaProviders": [],
  "SeoTags": [
    "content-type: text/html; charset=UTF-8"
  ],
  "HtmlLanguage": "en-US",
  "HasRobots": true,
  "HasSitemap": true,
  "SecurityHeaders": [
    "HSTS"
  ],
  "CookiesObserved": [],
  "XhrApiHints": [],
  "SitemapCounts": {
    "total_urls": 2
  },
  "ChatWidgets": [],
  "ABTesting": [],
  "PrivacyConsent": [],
  "EmailMarketing": [],
  "WebFonts": [
    "Google Fonts"
  ],
  "DynamicJs": [
    "jQuery (script Resource)",
    "Web Server: nginx",
    "Bootstrap (CSS Classes)",
    "Tailwind CSS (CSS Classes)",
    "React (CDN Detection)",
    "jQuery (CDN Detection)",
    "REST/GraphQL API (Pattern Detection)",
    "ES6+ JavaScript Features"
  ],
  "ResourceHosts": [
    "rndayala.com",
    "s0.wp.com",
    "stats.wp.com",
    "gmpg.org",
    "secure.gravatar.com",
    "fonts-api.wp.com",
    "widgets.wp.com",
    "jetpack.wordpress.com",
    "public-api.wordpress.com",
    "0.gravatar.com",
    "1.gravatar.com",
    "2.gravatar.com",
    "fonts.gstatic.com",
    "i0.wp.com",
    "c0.wp.com",
    "wp.me"
  ],
  "CssFrameworks": [],
  "BuildTools": [
    "Modern JS Build Tool (inferred from React)"
  ],
  "ServerTech": [
    "PHP (inferred from WordPress)"
  ],
  "DatabaseHints": [],
  "PageTitle": "Bits, Bytes and Brains | A Learning Journey &#8211; Coding Adventures",
  "MetaDescription": "A Learning Journey - Coding Adventures",
  "ImageCount": 8,
  "ScriptCount": 15,
  "LinkCount": 26,
  "Errors": [
    "Reverse DNS failed: No such host is known."
  ],
  "UiFrameworks": [
    "D3.js",
    "Slate",
    "Swiper",
    "Bootstrap (Class Names)",
    "Vuetify (Class Names)",
    "Angular Material (Class Names)",
    "Tailwind CSS (Class Names)",
    "Ionic (Class Names)"
  ]
}