【设计模式学习】单例模式

package Single;
/**
 * 单例模式
 * @author DMW
 */
public class Main {

    /**
     * 测试效率 
     * 饿汉式最快---------22ms
     * 懒汉式相对很慢------654ms
     * 相差一两个量级
     * @param args
     */

    
    /**
     * 对比：
     * 饿汉式效率快，不可延时加载
     * 懒汉式效率慢，可延时加载
     * 
     * 静态内部类，效率高，可延时加载
     * 枚举,效率高，不可延时加载（防止反射获取）
     * @param args
     */
    
    /**
     * 选择：
     * 资源少，不需要延迟加载
     * 枚举 优于 饿汉式
     * 资源多，需要延迟加载
     * 静态内部类 优于 懒汉式 
     * @param args
     */
    
    public static void main(String[] args) {
        SingleDemo5 instance1 = SingleDemo5.INSTANCE;
        SingleDemo5 instance2 = SingleDemo5.INSTANCE;
    
        
        System.out.println(instance1);
        System.out.println(instance2);
    }
    

}
 

package Single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.CountDownLatch;

/**
 * 反射获取单例
 * @author DMW
 * @2019年1月15日
 */
public class Main2 {
    
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        SingleDemo2 instance1 = SingleDemo2.getInstance();
        SingleDemo2 instance2 = SingleDemo2.getInstance();
        
        System.out.println(instance1);
        System.out.println(instance2);
        
        Class<SingleDemo2> clazz=(Class<SingleDemo2>) Class.forName("Single.SingleDemo2");
        Constructor<SingleDemo2> constructor = clazz.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        
        SingleDemo2 newInstance1 = constructor.newInstance();
        SingleDemo2 newInstance2 = constructor.newInstance();
        
        
        System.out.println(newInstance1);
        System.out.println(newInstance2);
        
        
    }

}
 

package Single;

import java.util.concurrent.CountDownLatch;

public class Main3 {

    public static void main(String[] args) throws InterruptedException {

        long start =System.currentTimeMillis();
        int threadNum =10;
        final CountDownLatch c= new CountDownLatch(threadNum);
        
        for (int i = 0; i < threadNum; i++) {
            
            new Thread( new Runnable() {
                public void run() {
                    for (int j = 0; j < 9999999; j++) {
//                        SingleDemo1 instance = SingleDemo1.getInstance(); 
//                        SingleDemo2 instance = SingleDemo2.getInstance(); 
//                        SingleDemo3 instance = SingleDemo3.getInstance(); 
//                        SingleDemo4 instance = SingleDemo4.getInstance(); 
                        SingleDemo5 instance = SingleDemo5.INSTANCE; 
                    }
                    c.countDown();
                }
            }).start();
            
        }
        c.await();
        long end =System.currentTimeMillis();
        System.out.println(end -start);
        
    }

}
 

package Single;
/**
 * 饿汉式
 * @author DMW
 * @2019年1月15日
 */
public class SingleDemo1 {

    /**
     * 1.构造器私有
     * 2.static 属性
     * 3.公开方法
     */
    
     //类初始化，立即加载，非延时加载。 可能不用，存在资源浪费
    private static SingleDemo1 instance =new SingleDemo1();
    
    SingleDemo1(){
        
    }
    
    //方法不用同步，效率高
    public static SingleDemo1 getInstance(){
        return instance;
    }
    
    
}
 

package Single;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 饿汉式
 * @author DMW
 * @2019年1月15日
 */
public class SingleDemo2 implements Serializable{

    /**
     * 1.私有构造器
     * 2.static属性
     * 3.公开方法
     */
    
    
    private static SingleDemo2 instance;
    
    private SingleDemo2(){
        //防止反射获取
        if(instance != null){
            throw new RuntimeException();
        }
    }
    //延迟加载，使用时创建
    public static synchronized SingleDemo2 getInstance(){
        if(instance == null)
            instance =new SingleDemo2();
        return instance;
        
    }
    
    //反序列化
    private Object readResolve() throws ObjectStreamException{
        return instance;
    }
    
}
 

package Single;
/**
 * 双重锁检测（据说有问题）
 * @author DMW
 * @2019年1月15日
 */
public class SingleDemo3 {

    private static SingleDemo3 instance = null;
    
    private SingleDemo3(){}
    
    public static SingleDemo3 getInstance(){
        if(instance ==null){
            SingleDemo3 s;
            synchronized (SingleDemo3.class) {
                s=instance;
                synchronized (SingleDemo3.class){
                    if(s==null){
                        s = new SingleDemo3();
                    }
                }
            }
        }
        return instance;
    }
    
    
}
 

package Single;

/**
 * 静态内部类实现
 * @author DMW
 * @2019年1月15日
 */
public class SingleDemo4 {

    private static class SingleDemo4Instance{
        private static final SingleDemo4 instance = new SingleDemo4();
    }
    
    private SingleDemo4(){}
    
    //方法不加锁，效率高
    public static SingleDemo4 getInstance(){
        return SingleDemo4Instance.instance;
    }
}
 

package Single;

/**
 * 枚举实现
 * @author DMW
 * @2019年1月15日
 */
public enum SingleDemo5 {
    
    // 非演示加载
    INSTANCE;

    public void doSomething(){
        
    }
}