java23种设计模式(1)-单例模式

package singleton;
/**
 * 饿汉式单例模式
 */
public class Singleton {
    //方法区静态常量池初始化对象
    private static final Singleton singleton = new Singleton();
    //构造方法私有化，不让外部new
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
    public void m(){
        System.out.println("m");
    }
    public static void main(String Args[]){
        Singleton p1 = Singleton.getInstance();
        Singleton p2 = Singleton.getInstance();
        System.out.println(p1 == p2);
    }
}

package singleton;
/**
 * 懒汉式：用的时候进行初始化
 */
public class Singleton2 {
    //不需要final，在加final时需要初始化
    private static Singleton2 singleton2;
    private Singleton2(){}
    public static synchronized Singleton2 getInstance(){
        //在此区间可能出现线程不安全
        //因此需要加锁使得线程同步，缺点是效率降低
        if(singleton2 == null){
            try{
                Thread.sleep(10);
            }catch(Exception e){
                e.printStackTrace();
            }
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
    public void m(){
        System.out.println("m");
    }
    public static void main(String[] args) throws Exception{
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                //从打印区间看看对象的hash码是否相同
                System.out.println(Singleton2.getInstance().hashCode());
            }).start();
        }
    }
}

package singleton;
public class Singleton3 {
    //不需要final，在加final时需要初始化
    private static Singleton3 singleton3;
    private Singleton3(){}
    public static  Singleton3 getInstance(){
        //在此区间可能出现线程不安全
        //因此需要加锁使得线程同步，缺点是效率降低
        if(singleton3 == null){
            //因此需要双重检查
            synchronized (Singleton3.class){
                if(singleton3 == null){
                    try{
                        Thread.sleep(10);
                    }catch(Exception e){
                        e.printStackTrace();
                    }
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }
    public void m(){
        System.out.println("m");
    }
    public static void main(String[] args) throws Exception{
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                //从打印区间看看对象的hash码是否相同
                System.out.println(Singleton3.getInstance().hashCode());
            }).start();
        }
    }
}

package singleton;
/**
 * 完美的写法
 */
public class Singleton4 {
    private Singleton4(){}
    //使用静态内部类
    private static class Singleton4Hold{
        private final static Singleton4 singleton4 = new Singleton4();
    }
    public static Singleton4 getInstance(){
        return Singleton4.getInstance();
    }
    public void m(){
        System.out.println("m");
    }
    public static void main(String[] args) throws Exception{
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                //从打印区间看看对象的hash码是否相同
                System.out.println(Singleton4.getInstance().hashCode());
            }).start();
        }
    }
}

package singleton;
public enum Singleton5 {
    INSTANCE;
    public void m(){}
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(Singleton5.INSTANCE.hashCode());
            }).start();
        }
    }
}