学习之路---java设计模式--单列模式的8种学法

public class SingleObject {
    private static final SingleObject singleObject=new SingleObject();

    private SingleObject(){}

    public static SingleObject getSingleObject(){
        return singleObject;
    }

    public void opeartion(){
        System.out.println("SingleObject----------------");
    }
}

public class SingletonObject {
    private static SingletonObject singleObject ;

    private SingletonObject(){}

    public static SingletonObject getSingleObject(){
        if(singleObject == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleObject = new SingletonObject();
        }
        return singleObject;
    }

    public void opeartion(){
        System.out.println("SingleObject----------------");
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject.getSingleObject().hashCode());
            }).start();
        }
    }
}

public class SingletonObject1 {
    private static SingletonObject1 singleObject ;

    private SingletonObject1(){}

    public static synchronized SingletonObject1 getSingleObject(){
        if(singleObject == null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleObject = new SingletonObject1();
        }
        return singleObject;
    }

    public void opeartion(){
        System.out.println("SingleObject----------------");
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject1.getSingleObject().hashCode());
            }).start();
        }
    }
}

public class SingletonObject2 {
    private static SingletonObject2 singleObject ;

    private SingletonObject2(){}

    public static SingletonObject2 getSingleObject(){
        if(singleObject == null){
            synchronized(SingletonObject2.class) {//多线程情况下 不能保证一致
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                singleObject = new SingletonObject2();
            }
        }
        return singleObject;
    }

    public void opeartion(){
        System.out.println("SingleObject----------------");
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject2.getSingleObject().hashCode());
            }).start();
        }
    }
}

public class SingletonObject3 {
    private static volatile SingletonObject3 singleObject ;

    private SingletonObject3(){}

    public static SingletonObject3 getSingleObject(){
        if(singleObject == null) {
            synchronized (SingletonObject3.class) {
            if (singleObject == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    singleObject = new SingletonObject3();
                }
            }
        }
        return singleObject;
    }

    public void opeartion(){
        System.out.println("SingleObject----------------");
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject3.getSingleObject().hashCode());
            }).start();
        }
    }
}

public class SingletonObject4 {

    private SingletonObject4(){}

    private static class SingletonInstance{
        private final static SingletonObject4 instance = new SingletonObject4();
    }

    public static SingletonObject4 getInstance(){
        return SingletonInstance.instance;
    }

    public void operation(){
        System.out.println("------------静态内部类方式----------");
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject4.getInstance().hashCode());
            }).start();
        }
    }

}

public enum  SingletonObject5 {

    INSTANCE;

    public void operation(){
        System.out.println("枚举单列---完美中的完美------可以防止反序列化");
    }
    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(SingletonObject5.INSTANCE.hashCode());
            }).start();
        }
    }
}