【JAVA】三【设计模式】一 JAVA 单例枚举

男娘i 2022-07-24 06:25 143阅读 0赞

# **【JAVA】三 【设计模式】一 JAVA 单例 枚举** #

# **单例特点** #

*  **单例类只能有一个实例。**
 *  **单例类必须自己创建自己的唯一实例**。
 *  **单例类必须给所有其他对象提供这一实例。**

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

# **懒汉** #

**线程不安全**  
**伪单例 可通过Java反射得到多个对象**

public class Singleton {
        private static Singleton instance;
    
        private Singleton() {
        }
    
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = Single.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

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

# **懒汉** #

**线程安全 synchronized 实现效率低**  
**伪单例 可通过Java反射得到多个对象**

package com.cn.mark.designmode;
    
    import java.lang.reflect.Constructor;
    
    public class Single {
        private static Single instance;
    
        private Single() {
        }
    
        public static synchronized Single getInstance() {
            if (instance == null) {
                instance = new Single();
            }
            return instance;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = Single.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

# **饿汉** #

**线程安全 instance在类装载时就实例化**  
**伪单例 可通过Java反射得到多个对象**

package com.cn.mark.designmode;
    
    import java.lang.reflect.Constructor;
    
    public class Single {
        private static Single instance = new Single();
    
        private Single() {
        }
    
        public static Single getInstance() {
            return instance;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = Single.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

# **饿汉** #

**线程安全 static 代码块 实例化instance**  
**伪单例 可通过Java反射得到多个对象**

package com.cn.mark.designmode;
    
    import java.lang.reflect.Constructor;
    
    public class Single {
        private static Single instance = null;
        static {
            instance = new Single();
        }
    
        private Single() {
        }
    
        public static Single getInstance() {
            return instance;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = Single.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

# **静态内部类** #

**线程安全 SingleHolder 类加载是实例化 instance**   
**伪单例 可通过Java反射得到多个对象**

**Single类被装载了，instance不一定被初始化。因为SingleHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingleHolder类，从而实例化instance。**

package com.cn.mark.designmode;
    
    import java.lang.reflect.Constructor;
    
    public class Single {
        private static class SingleHolder {
            private static final Single INSTANCE = new Single();
        }
    
        private Single() {
        }
    
        public static final Single getInstance() {
            return SingleHolder.INSTANCE;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = Single.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

# **DCL 双重校验锁** #

**线程安全**   
**伪单例 可通过Java反射得到多个对象**

package com.cn.mark.designmode;
    
    import java.lang.reflect.Constructor;
    
    /**
     * Singleton pattern example with Double checked Locking
     */
    public class DoubleCheckedLockingSingleton {
        
        private volatile DoubleCheckedLockingSingleton INSTANCE;
    
        private DoubleCheckedLockingSingleton() {
        }
    
        public DoubleCheckedLockingSingleton getInstance() {
            if (INSTANCE == null) {
                synchronized (DoubleCheckedLockingSingleton.class) {
                    // double checking Singleton instance
                    if (INSTANCE == null) {
                        INSTANCE = new DoubleCheckedLockingSingleton();
                    }
                }
            }
            return INSTANCE;
        }
    
        public static void main(String[] args) {
            try {
                Class cls = DoubleCheckedLockingSingleton.class;
                Constructor con = cls.getDeclaredConstructor(null);
                con.setAccessible(true);
                Object first = con.newInstance(null);
                Object second = con.newInstance(null);
                System.out.println(first);
                System.out.println(second);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

# **枚举** #

**线程安全 thread-safe**  
**单例**

package com.cn.mark.designmode;
    
    public enum SingleEnum {
    
        INSTANCE {
    
            @Override
            protected void whateverMethod() {
                System.out.println("whateverMethod");
            }
    
        };
    
        protected abstract void whateverMethod();
    
    }

### **static instance** ###

###  **abstract class** ###

Enum类源码片断

public abstract class Enum<E extends Enum<E>>
            implements Comparable<E>, Serializable {

###  **overwrite object readObject** ###

Enum类源码片断

private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
            throw new InvalidObjectException("can't deserialize enum");
        }