单例模式

单例模式

饿汉式

• 类加载时完成实例化,保证线程安全
• 没有Lazy Loding(懒加载)的效果,如果没用此实例,则会资源浪费

package singlecase;


/**
 * 静态常量饿汉式
 * 优点,类加载时完成实例化,避免了线程同步问题
 * 缺点,在类装载的时候实例化,没有Lazy Loding(懒加载)的效果,如果没用此实例,则会资源浪费
 */
public class type1 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton==singleton2);
    }


}

class Singleton{
    //1.构造器私有化
    private  Singleton(){

    }
    //2.本类创建对象实例
    private final static Singleton instane = new Singleton();

    //对外返回公有静态
    public static Singleton getInstance(){
        return instane;
    }
}

线程不安全的懒汉式

• 线程不安全,可能产生多个实例,不推荐用

package singlecase;

/**
 * 线程不安全的懒汉式写法
 *运行在加载
 * 线程不安全,可能产生多个实例,不推荐用
 */
public class type3 {
    public static void main(String[] args) {
        Singleton3 singleton3 = Singleton3.getInstans();
        Singleton3 singleton31 = Singleton3.getInstans();
        System.out.println(singleton3 == singleton31);
    }
}
class Singleton3{
    private static  Singleton3 instans;
    //私有
    private Singleton3(){
    }

    public static Singleton3 getInstans(){  //线程安全就在这里加一个synchronized就行了
        if (instans == null){
            instans = new Singleton3();
        }
        return instans;
    }
}

线程安全效率低的懒汉式

• 每次都要调用synchronized,效率低,不推荐

package singlecase;

/**
 * 线程安全的懒汉式写法
 *运行在加载
 * 同步效率低不推荐用
 */
public class type4 {
    public static void main(String[] args) {
        Singleton4 singleton3 = Singleton4.getInstans();
        Singleton4 singleton31 = Singleton4.getInstans();
        System.out.println(singleton3 == singleton31);
    }
}

class Singleton4{
    private static  Singleton4 instans;
    //私有
    private Singleton4(){
    }

    public static synchronized Singleton4 getInstans(){  //线程安全就在这里加一个synchronized就行了
        if (instans == null){
            instans = new Singleton4();
        }
        return instans;
    }
}

线程安全且效率高的懒汉式

• 实例对象定义为volatile,防止指令重排
• 实例化之后便不会使用synchronized,效率高,推荐使用

package singlecase;

import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;

import java.time.Instant;

/**
 * 线程安全且效率高的懒汉式写法
 * 推荐使用
 */
public class type5 {
    public static void main(String[] args) {
        Singleton5 singleton3 = Singleton5.getInstans();
        Singleton5 singleton31 = Singleton5.getInstans();
        System.out.println(singleton3 == singleton31);
    }
}

class Singleton5{
    private Singleton5(){

    }
    private volatile static Singleton5 instans;//定义为volatile,防止指令重排

    public static Singleton5 getInstans(){
        if (instans==null){
            synchronized (Singleton5.class){
                if (instans==null){
                    instans = new Singleton5();
                }
            }

        }
        return instans;
    }
}

线程安全且效率高的静态内部类的懒汉式

• 装载类的时候是线程安全的,所以实例化的时候jvm会保证线程的安全

package singlecase;

/**
 * 线程安全且效率高的静态内部类的懒汉式写法
 * 推荐使用
 * 装载类的时候是线程安全的,所以实例化的时候jvm会保证线程的安全
 */
public class type6 {
    public static void main(String[] args) {
        Singleton6 singleton3 = Singleton6.getInstans();
        Singleton6 singleton31 = Singleton6.getInstans();
        System.out.println(singleton3 == singleton31);
    }
}

class Singleton6{
    private Singleton6(){

    }
    private volatile static Singleton6 instans;//定义为volatile,防止指令重排

    private static class getSingle{//静态内部类
        private static final Singleton6 INSTANSE = new Singleton6();//调用静态内部类才实例化,线程安全,
    }

    public static Singleton6 getInstans(){
        return getSingle.INSTANSE;
    }
}

枚举类的单例模式

• 线程安全效率高

package singlecase;

/**
 * 枚举类的单例模式
 *
 */
public class type7 {
    public static void main(String[] args)  {
        Singleon7 singleon7 = Singleon7.INSTANCE;
        Singleon7 singleon72 = Singleon7.INSTANCE;
        System.out.println(singleon7==singleon72);
    }
}

enum Singleon7{
    INSTANCE;
    public void sayOk(){
        System.out.println("ok");
    }
}