单例模式 初识

单例模式

1.实例一

public class SingleTon {
    private static SingleTon singleton=null;                      //第一次初始化对象时线程不安全
    public static SingleTon getSingleton(){
        if(singleton==null){
               singleton=new SingleTon();
       }
        return singleton;
    }
    private SingleTon(){}
}

2.饿汉式
public class SingleTonE{
    private static final SingleTonE singleTonE=new SingleTonE();   //类加载的时候就已经占内存了， 这种占内存，线程安全
    private SingleTonE(){}
    public SingleTonE getSingleton(){
        return singleTonE;
    }
}

3.懒汉式一
public class SingleTon {                                             //同实例一
    private static SingleTon singleton=null;
    public static SingleTon getSingleton(){
        if(singleton==null){
               singleton=new SingleTon();
       }
        return singleton;
    }
    private SingleTon(){}
}

4.懒汉式(线程安全)                                                       //synchronized 占运行性能
public class SingleTonL {
    private volatile static SingleTonL singleTon = null;
    private SingleTonL() {}
    synchronized public static SingleTonL getSingleton() {
        if (singleTon == null) {
            singleTon = new SingleTonL();
        }
        return singleTon;
    }
}

5.懒汉式(改造一)
public class SingleTonL {                                               
    private volatile static SingleTonL singleTon = null;
    private SingleTonL() {}
    public static SingleTonL getSingleton() {
        if (singleTon == null) {                                 //if (singleTon == null) {  线程不安全
            synchronized (SingleTonL.class) {
                      singleTonL = new SingleTonS();
               }
            return singleTon;
        }
}

6.懒汉式(双重检查机制)
public class SingleTonS {
    private volatile static SingleTonS singleTon = null;   //volatile ：保证这块内存中取到的对象是同一个对象，如果第一次取这个对象 的时候发生了变化，就会把把发生变化的对象放回原来的【创建对象的正常流程：1)分配内存2）实例化对象3）把这个对象指向创建的内存空间】
    private SingleTonS() {}
    public static SingleTonS getSingleton() {
        if (singleTon== null) {
            synchronized (SingleTonS.class) {
                if (singleTon == null) {
                    singleTon = new SingleTonS();
                }
            }
        }
        return singleTon;
    }
}

7.IoDH(静态内部类)
public class SingleTonIoDH(){                          //（网上推荐） 但是我认为还不如恶汉    这种会编译的时候占用两个内存
    private static class HolderClass(){
        private static SingleTonIoDH singleton=new SingleTonIoDH();
    }
    private SingleTonIoDH(){}
    public SingleTonIoDH getSingleton(){
        return HolderClass.singleton;
    }
}

8.枚举
public enum SingleTonM(){                          //同恶汉
    SINGLETON;
}

静态代码块：有些代码必须在项目启动的时候就执行，这种代码是主动执行的(当类被载入时，静态代码块被执行，且只被执行一次，静态块常用来执行类属性的初始化)

静态方法：需要在项目启动的时候就初始化,在不创建对象的情况下，这种代码是被动执行的（静态方法在类加载的时候 就已经加载到内存中 可以用类名直接调用）

两者的区别就是:静态代码块是自动执行的;
静态方法是被调用的时候才执行的。

注：静态方法中如果初始化当前对象了，注意这时候也并没有执行，因为静态方法是被动执行的。