23种设计模式之一（单例模式）

悠悠 2024-02-27 02:19 23阅读 0赞

#### 概念 ####

一个类永远只有一个对象存在。

#### 实现方式 ####

##### 方式1（饿汉式 - 线程安全） #####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 饿汉式：线程安全
     * 类加载到内存后，就实例化一个单例，JVM保证线程安全
     * 简单易用，推荐使用！
     * 唯一缺点：不管用到与否，类装载时就完成实例化
     */
    public class Singleton01 {
        
        private static Singleton01 instance = new Singleton01();
    
        private Singleton01(){
        }
    
        public static Singleton01 getInstance(){
        
            return instance;
        }
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton01.getInstance().hashCode())).start();
            }
        }
    }

##### 方式2（懒汉式 - 线程不安全） #####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 懒汉式：线程不安全
     */
    public class Singleton02 {
        
        private static Singleton02 instance;
    
        private Singleton02() {
        }
    
        public static Singleton02 getInstance() {
        
            instance = new Singleton02();
            return instance;
        }
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton02.getInstance().hashCode())).start();
            }
        }
    }

##### 方式3（懒汉式 - 线程安全 - 加锁 - 效率下降） #####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 懒汉式：线程安全（加锁实现，但是效率下降）
     */
    public class Singleton03 {
        
        private static Singleton03 instance;
    
        private Singleton03() {
        }
    
        public static synchronized Singleton03 getInstance() {
        
            if (instance == null) {
        
                instance = new Singleton03();
            }
            return instance;
        }
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton03.getInstance().hashCode())).start();
            }
        }
    }

##### 方式4（懒汉式 - 线程安全 - DCL - 效率提升 - 较完美的实现方式） #####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 懒汉式：线程安全
     * DCL: Double Check Loading
     * 较为完美的单例写法
     */
    public class Singleton04 {
        
        private static volatile Singleton04 instance; // volatile：防止指令重排
    
        private Singleton04() {
        }
    
        public static Singleton04 getInstance() {
        
            if (instance == null) {
        
                // 双重检查
                synchronized (Singleton04.class) {
        
                    if (instance == null) {
        
                        instance = new Singleton04();
                    }
                }
            }
            return instance;
        }
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton04.getInstance().hashCode())).start();
            }
        }
    }

#### 方式5（内部类实现 - 线程安全 - 懒加载 - 较完美的实现方式） ####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 静态内部类
     * JVM 保证单例，且线程安全，不用加锁
     * 加载外部类时不会加载内部类，变相实现了懒加载（Lazy Loading）
     * 较为完美的单例写法
     */
    public class Singleton05 {
        
    
        private Singleton05() {
        }
    
        private static class Singleton05Holder {
        
            private static final Singleton05 instance = new Singleton05();
        }
    
        public static Singleton05 getInstance() {
        
            return Singleton05Holder.instance;
        }
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton05.getInstance().hashCode())).start();
            }
        }
    }

##### 方式6（枚举类实现 - 线程安全 - 防止反序列化 - 最完美的实现方式） #####

package mirale.luna.design.patterns.singleton;
    
    /**
     * Created by Miracle Luna on 2020/12/15
     *
     * 枚举单例
     * 不仅实现了线程同步，而且防止了反序列化
     * 最完美的单例写法
     */
    public enum Singleton06 {
        
        instance;
    
        /**
         * 通过查看 hashCode值 是否一致，判断是否线程安全
         * @param args
         */
        public static void main(String[] args) {
        
            for (int i = 0; i < 100; i++) {
        
                new Thread(() -> System.out.println(Singleton06.instance.hashCode())).start();
            }
        }
    }