单例模式之静态内部类实现

深藏阁楼爱情的钟 2024-02-19 18:46 67阅读 0赞

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例。即一个类只有一个对象实例。

最常用的单例模式有恶汉式和懒汉式两种方式，除此之外还有一种通过静态内部类实现的单例模式。

原文摘自:[https://www.cnblogs.com/Trainoo/p/8044606.html][https_www.cnblogs.com_Trainoo_p_8044606.html]

1.代码示例

public class Singleton
    {
        private Singleton(){}
        
        static {
            System.out.println("This's static code block!");
        }
        
        private static class SingletonHandler {
            private static Singleton singleton = new Singleton();
            static {
                System.out.println("This's innerClass's static code block");
            }
        }
        
        public static Singleton getInstance(){
            return SingletonHandler.singleton;
        }
        
        public static void display(){
            System.out.println("This's display!");
        }
    }

public class SingletonTest
    {
        private SingletonTest(){}
        
        static class MyThread extends Thread {
            @Override
            public void run()
            {
                super.run();
                System.out.println("Thread running_"+Singleton.getInstance());
            }
        }
        
        public static void main(String[] args)
        {
            MyThread th1 = new MyThread();
            MyThread th2 = new MyThread();
            MyThread th3 = new MyThread();
            /*@1
            th1.start();
            th2.start();
            th3.start();
            */
            
            /*@2
            Singleton.display();
            */
        }
    }

2. 运行结果及解释

情况一(注释 @1代码，注释 @2的代码)

//运行结果 为空

解释：外部类和内部类都没有加载

情况二(执行 @1代码)

//运行结果
    This's static code block!
    This's innerClass's static code block
    Thread running_com.singleton.Singleton@4f19c297
    Thread running_com.singleton.Singleton@4f19c297
    Thread running_com.singleton.Singleton@4f19c297

解释： 外部类Singleton和内部类SingletonHandler都加载了，因为他们的静态代码块加载了

情况三(注释 @1代码，执行 @2的代码)

//运行结果
    This's static code block!
    This's display!

解释：外部类加载了，而内部类没有加载，因为加载了类，就一定会执行静态代码块

3. 结论

线程安全分析：虚拟机会保证一个类的构造器<clinit>()方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的(简单而言: 当调用return SingletonHandler.singleton;时会加载内部类,若在多线程情况下，则只有一个线程去执行这个类)详情可以参考这篇博客:[https://blog.csdn.net/yao\_94/article/details/82764741][https_blog.csdn.net_yao_94_article_details_82764741]

终上实验：内部类SingletonHandler只有在getInstance()方法第一次调用的时候才会被加载（实现了延迟加载效果），而且其加载过程是线程安全的（实现线程安全）。内部类加载的时候只实例化了一次instance

[https_www.cnblogs.com_Trainoo_p_8044606.html]: https://www.cnblogs.com/Trainoo/p/8044606.html
[https_blog.csdn.net_yao_94_article_details_82764741]: https://blog.csdn.net/yao_94/article/details/82764741