Head First Design Patterns——单例模式

爱被打了一巴掌 2023-07-24 03:11 17阅读 0赞

### 文章目录 ###

*   *  1）饿汉式（静态常量）
     *  2）饿汉式（静态代码块）
     *  3）懒汉式（线程不安全）
     *  4）懒汉式（线程安全，同步方法）
     *  5）懒汉式（线程安全，同步代码块）
     *  6）双重检查（推荐使用）
     *  7）静态内部类（推荐使用）
     *  8）枚举方式

--------------------

> 单例模式：也叫单件模式，可以用来创建独一无二的，只能有一个实例的对象，并且该类只提供一个取得其对象实例的方法(static)！它是所有设计模式中最简单的，它的类图只有一个类：

## 1）饿汉式（静态常量） ##

> 创建的步骤：  
> 1.构造器私有化（防止 new来获得实例）  
> 2.类的内部创建对象  
> 3.向外界暴露一个静态的公共方法。getInstance  
> 4.代码实现

//饿汉式（静态变量)
    class Singleton{ 
    
        //1.构造器私有化
        private Singleton(){ 
    
        }
    
        //2.本类内部创建对象实例
        private final static Singleton instance = new Singleton();
    
        //3.提供一个公有的静态方法，返回实例对象
        public static Singleton getInstance(){ 
            return instance;
        }
    }
    
    public class Singleton1 { 
        public static void main(String[] args) { 
    
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
    
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }

*  测试结果  
    ![在这里插入图片描述][20200409113529196.png]  
    两个对象实例的hashCode值相等，说明 new的两个对象是同一个，这样就避免了new实例多个对象！
 *  优缺点：

> 优点：这种写法比较简单，就是在类装载的时候就完成 了实例化，避免了线程同步问题。  
> 缺点：  
> 1.在类装载时就完成 了实例化，油源有达到Lazy Loading的效果，如果从始至终从未使用过这个实例，则会造成内存的浪费。  
> 2.这种方式基于classLoader机制避免了多线程的同步问题，不过，Instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到Lazy Loading的效果。

*  结论：

> 这种单例模式可用，可能会**造成内存浪费**！

--------------------

## 2）饿汉式（静态代码块） ##

> 这和方式和静态常量方法类似 ，只是在内部将创建实例对象的操作放到了静态代码块中进行了

*  代码实现

//饿汉式（静态代码块）
    
    class Singleton{ 
    
        //1.构造器私有化
        private Singleton(){ 
    
        }
    
        //2.本类内部创建对象实例
        private final static Singleton instance;
    
        static { //在静态代码块中创建单例对象
            instance = new Singleton();
        }
    
        //3.提供一个公有的静态方法，返回实例对象
        public static Singleton getInstance(){ 
            return instance;
        }
    }
    
    public class Singleton2 { 
        public static void main(String[] args) { 
    
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
    
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200409113529196.png]
 *  结论：

> 这种单例模式也是可用的，但是可能会造成内存浪费

--------------------

## 3）懒汉式（线程不安全） ##

*  代码实现

public class SingletonTest03 { 
        public static void main(String[] args) { 
    
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }
    
    
    class Singleton{ 
        private static Singleton instance;
    
        private Singleton(){ }
    
        //提供一个静态的公有方法，使用到该方法时，才去创建instance
        public static Singleton getInstance(){ 
            if (instance == null) { 
                instance = new Singleton();
            }
            return instance;
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200409144346277.png]
 *  总结：

> 提供一个静态的公有方法，使用到该方法时，才去创建instance  
> 1.起到了Lazy Loading的效果，但是只能在单线程下使用  
> 2.如果在多线程下，一个线程进入了if(singleton == null)判断语句时，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

*  结论：

**在实际开发中，不要使用这种方式。**

--------------------

## 4）懒汉式（线程安全，同步方法） ##

*  代码实现

public class SingletonTest04 { 
        public static void main(String[] args) { 
    
            System.out.println("懒汉式（线程安全，同步方法）");
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }
    
    //懒汉式（线程安全，同步方法）
    class Singleton{ 
        private static Singleton instance;
    
        private Singleton(){ }
    
        //提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
        //synchronized
        public static synchronized Singleton getInstance(){ 
            if (instance == null) { 
                instance = new Singleton();
            }
            return instance;
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200409145819688.png]
 *  总结：

1.  解决了线程不安全问题
2.  效率太低了，每个线程都在想获得类的实例时候，执行getInstance()方法都要进行执行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该实例，直接return 就行了，方法进行同步的效率太低了。

*  总结  
    **在实际开发中，不推荐使用这种方式**

--------------------

## 5）懒汉式（线程安全，同步代码块） ##

public class SingletonTest05 { 
        public static void main(String[] args) { 
    
            System.out.println("懒汉式 同步代码块");
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }
    
    //懒汉式（线程安全，同步方法）
    class Singleton{ 
    
        private static  Singleton instance;
    
        private Singleton(){ }
    
        //提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
        //synchronized
        public static  Singleton getInstance(){ 
            if (instance == null) { 
                synchronized (Singleton.class) { 
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200409151422498.png]
 *  总结：

1.  这种方式，本意是想对第四种方式的改进，因为前面同步方法效率太低了，改为同步 产生实例化的代码块。
2.  **但是这种同步并不能起到线程同步的作用。**，假如一个线程进入到if(Singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

*  结论：  
    **在实际开发中，不能使用这种方式。**

--------------------

## 6）双重检查（推荐使用） ##

*  代码实现

public class SingletonTest06 { 
        public static void main(String[] args) { 
    
            System.out.println("双重检查");
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }
    
    //懒汉式（线程安全，同步方法）
    class Singleton{ 
    
        private static volatile Singleton instance;
    
        private Singleton(){ }
    
        //提供一个静态的公有方法,加入双重检查代码，解决线程安全问题，同时解决懒加载问题
        //同时保证了效率
        public static Singleton getInstance(){ 
            if (instance == null) { 
                synchronized (Singleton.class) { 
                    if (instance == null){ 
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

*  运行结果  
    ![在这里插入图片描述][20200409153524346.png]
 *  总结

1.  Double-Check概念是多线程开发中学使用到的，我们进行了两次if (instance == null)检查，这样就可以保证线程安全了
2.  这样，实例化代码只执行一次，后面再次访问时，判断if (instance == null)，直接 return实例化对象，也就避免了反复执行方法同步 。
3.  线程安全，延迟加载，效率较高

*  结论：  
    **在开发中，推荐使用这种单例设计模式!**

--------------------

## 7）静态内部类（推荐使用） ##

> 基本介绍：

1.  静态内部类不会在类装载时，直接执行，保证了懒加载
2.  在调用类中的方法时，再装载静态内部类，是可行的，JVM中进行类装载时是线程安全的

*  代码实现

public class SingletonTest7 { 
        public static void main(String[] args) { 
    
            System.out.println("静态内部类：单例模式");
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance == instance1);
            System.out.println("instance:"+instance.hashCode()+"\n"+"instance1:"+instance1.hashCode());
        }
    }
    
    //静态内部类
    class Singleton{ 
    
        private static volatile Singleton instance;
    
        private Singleton(){ }
    
        //静态内部类
        private static class SingletonInstance{ 
            private static final Singleton INSTANCE = new Singleton();
        }
    
        //提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE
        public static Singleton getInstance(){ 
            return SingletonInstance.INSTANCE;
        }
    }

*  运行结果  
    ![在这里插入图片描述][2020040915524847.png]
 *  总结

> 1.这种方式采用了类装载的机制来保证初始化实例时只有一个线程。  
> 2.静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会被装载SingletonInstance类，从而完成Singleton的实例化。  
> 3.类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。  
> 4.优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

*  结论  
    **推荐使用！**

--------------------

## 8）枚举方式 ##

*  代码实现

public class SingletonTest08 { 
        public static void main(String[] args) { 
    
            Singleton instance = Singleton.INSTANCE;
            Singleton instance1 = Singleton.INSTANCE;
            System.out.println(instance == instance1);
            System.out.println(instance.hashCode());
            System.out.println(instance1.hashCode());
    
            instance.sayHello();
        }
    }
    
    //使用枚举可以实现单例，推荐作用
    enum Singleton{ 
        INSTANCE;
        public void sayHello(){ 
            System.out.println("hello enum");
        }
    }

*  运行结果  
    ![在这里插入图片描述][2020040916162786.png]
 *  总结：

> 1.借助JDK1.5中添加的枚举来实现单例模式，不仅可以避免多线程同步 问题，而且还能防止反序列化重新创建新的对象

*  结论：  
    **强力推荐使用！！！**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70_pic_center]

**整理不易，如果大家觉得好的话，可以加关注，后续会整理更多的知识点！**

[20200409113529196.png]: /images/20230528/6d12fa5355154d2aa310ca37d5d11fa1.png
[20200409144346277.png]: /images/20230528/dc0b375baf4c49c5a74687302aef21dc.png
[20200409145819688.png]: /images/20230528/450f4aaab56e42dcbbb90b61f762eab6.png
[20200409151422498.png]: /images/20230528/2feb44a79c164d25bf89c4c64c849c32.png
[20200409153524346.png]: /images/20230528/3e2c8dcfe15942389a51f28ae8bf4c41.png
[2020040915524847.png]: /images/20230528/9af51a8d066f4692aef0e00a99abfcc0.png
[2020040916162786.png]: /images/20230528/28ceb539ee5e49ff83ef060281b95d35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjg5MzA4NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/226ba5104d394a80a5fd2b22a815f489.png