设计模式 - 学习笔记 - 单例模式Singleton Pattern

女爷i 2023-01-14 10:57 120阅读 0赞

### 设计模式 - 学习笔记 - 单例模式Singleton Pattern ###

*  学习总结
 *  应用场景
 *  代码示例
 *   *  饿汉 hungry
     *   *  1. 经典饿汉模式
         *  2. 枚举实现
         *  3. 客户端
     *  懒汉 lazy
     *   *  ~~1. 直接加 synchronized~~
         *  2. 静态内部类
         *  3. 双重检查锁
 *  参考资料

# 学习总结 #

1.  单列的核心就是这东西，我们只想要一份，无论多少人调用它。都是调这个实例。
2.  懒汉：调用时才创建实例，能省点是点。
3.  饿汉：初始化时直接生成实例，要用时直接调，无需等待。当然如果一直都没调它，那就活活浪费着。。。
4.  Java实现中考虑线程安全问题，衍生出了8种方式。其实好多是凑数的没啥意义。
5.  线程安全问题来自于`懒汉`模式`运行时`动态`创建`实例，多线程自然就会有撞车风险。`饿汉`模式就`不存在`线程安全问题了。

# 应用场景 #

1.  我们经常在工具类中使用单列。

# 代码示例 #

## 饿汉 hungry ##

### 1. 经典饿汉模式 ###

天然线程安全。  
至于 `new Singleton()` 拆出来放到单独的 `static` 块中的所谓变种，完全没分别讨论的意义，就是同一个东西。

public class Singleton1 { 
        private static Singleton1 instance = new Singleton1();
        private Singleton1 (){ }
        public static Singleton1 getInstance() { 
            return instance;
        }
    
        public void show(){ 
            System.out.println("饿汉模式");
        }
    }

### 2. 枚举实现 ###

饿汉。用枚举实现，Effective Java 作者 Josh Bloch 提倡的方式。

public enum Singleton2Enum { 
        INSTANCE;
    
        public void show(){ 
            System.out.println("饿汉枚举实现");
        }
    }

### 3. 客户端 ###

public class SingletonHungryDemo { 
        public static void main(String[] args) { 
            // 经典饿汉
            Singleton1.getInstance().show();
            // 枚举类
            Singleton2Enum.INSTANCE.show();
        }
    }

## 懒汉 lazy ##

### 1. 直接加 synchronized ###

懒汉：线程安全。synchronized 实现线程安全，但效率低。去掉能提高效率，但会线程不安全。

public class Singleton1ThreadSafe { 
        private static Singleton1ThreadSafe instance;
        private Singleton1ThreadSafe(){ }
        public static synchronized Singleton1ThreadSafe getInstance() { 
            if (instance == null) { 
                instance = new Singleton1ThreadSafe();
            }
            return instance;
        }
        
        public void show(){ 
            System.out.println("懒汉：线程安全");
        }
    }

### 2. 静态内部类 ###

懒汉：静态内部类。利用静态内部类显示调用时才会加载的特性实现懒加载。

public class Singleton2LazyStaticInnerClass { 
        private static class SingletonHolder { 
            private static final Singleton2LazyStaticInnerClass INSTANCE = new Singleton2LazyStaticInnerClass();
        }
        private Singleton2LazyStaticInnerClass(){ }
        public static final Singleton2LazyStaticInnerClass getInstance() { 
            return SingletonHolder.INSTANCE;
        }
        public void show(){ 
            System.out.println("懒汉：静态内部类。利用静态内部类显示调用时才会加载的特性实现懒加载。");
        }
    }

### 3. 双重检查锁 ###

懒汉：双重检查锁。在方法内部进行了加锁操作，同时使用 volatile 修饰 instance，防止 Java 指令重排，确保当变量 instance 被初始化成实例时，多个线程正确的处理 instance 变量。

public class Singleton3DoubleCheckLock { 
        private volatile static Singleton3DoubleCheckLock singleton;
        private Singleton3DoubleCheckLock (){ }
        
        public static Singleton3DoubleCheckLock getInstance() { 
            if (singleton == null) { 
                synchronized (Singleton3DoubleCheckLock.class) { 
                    if (singleton == null) { 
                        singleton = new Singleton3DoubleCheckLock();
                    }
                }
            }
            return singleton;
        }
        
        public void show(){ 
            System.out.println("懒汉：双重检查锁");
        }
    }

# 参考资料 #

[西瓜视频：23种设计模式第三讲：单例(单件)模式][23]

[23]: https://www.ixigua.com/6850839393981514253?id=6797952809057649166