设计模式之单例模式

• 简介
  单例模式是表示在一个程序中,某个类具有唯一的实例.

• 模式应用

• 类图

• 源码实现
  第一种:饿汉式,优点是代码简单,缺点是资源过早创建,不用的话浪费资源.

点击查看代码

package designpattern.singleton;

//饿汉式
public class Singleton1 {

    private static Singleton1 instance = new Singleton1();

    private Singleton1(){

    }

    public static Singleton1 getInstance(){
        return instance;
    }

}

第二种:懒汉式,优点是代码简单且实现按需加载,缺点是有线程安全问题

点击查看代码

package designpattern.singleton;

//懒汉式
public class Singleton2 {

    private static Singleton2 singleton2 = null;

    private Singleton2(){

    }

    public static Singleton2 getInstance(){
        if(singleton2 == null){
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

第三种:懒汉式,优点是代码简单且实现按需加载,线程安全,缺点是高并发场景下会造成多个线程等待,性能差

点击查看代码

package designpattern.singleton;

//懒汉式优化一 :synchronized
public class Singleton3 {


    private static Singleton3 singleton3 = null;

    private Singleton3(){

    }

    public static synchronized Singleton3 getInstance(){
        if(singleton3 == null){
            singleton3 = new Singleton3();
        }
        return singleton3;
    }
}

第四种:懒汉式双重检测,优点是代码简单且实现按需加载,线程安全,缺点是高并发场景下会造成多个线程等待,性能差

点击查看代码

package designpattern.singleton;

//懒汉式优化二 :双重检测
public class Singleton4 {


    private static Singleton4 singleton4 = null;

    private Singleton4(){

    }

    public static Singleton4 getInstance(){
        if(singleton4 == null){
            synchronized (Singleton4.class){
                singleton4 = new Singleton4();
            }
        }
        return singleton4;
    }
}

线程不安全

点击查看代码

package designpattern.singleton;

//懒汉式优化三 :双重检测优化
public class Singleton5 {


    private static volatile Singleton5 singleton4 = null;

    private Singleton5(){

    }

    public static Singleton5 getInstance(){
        if(singleton4 == null){
            synchronized (Singleton5.class){
                singleton4 = new Singleton5();
            }
        }
        return singleton4;
    }
}

内部类方式依赖jvm的底层机制实现了单例,开源框架常用这种方式

点击查看代码

package designpattern.singleton;

//懒汉式:内部类
public class Singleton6 {

    private static Singleton6 instance = null;

    private Singleton6(){

    }

    public static Singleton6 getInstance(){
        instance = Inner.singleton6;
        return instance;
    }

    static class Inner{
        private static Singleton6 singleton6 = new Singleton6();
    }
}

枚举方式实现

点击查看代码

package designpattern.singleton;

public enum Singleton7 {
    Singleton7;

    static Singleton7 getInstance(){
        return Singleton7;
    }
}

测试代码

点击查看代码

package designpattern.singleton;

public class TestSingleTon {
    public static void main(String[] args) {
        Singleton1 s1 = Singleton1.getInstance();
        Singleton1 s1_ = Singleton1.getInstance();
        System.out.println(s1_ == s1);


        Singleton2 s2 = Singleton2.getInstance();
        Singleton2 s2_ = Singleton2.getInstance();
        System.out.println(s2 == s2_);

        Singleton3 s3 = Singleton3.getInstance();
        Singleton3 s3_ = Singleton3.getInstance();
        System.out.println(s3_ == s3);

        Singleton4 s4 = Singleton4.getInstance();
        Singleton4 s4_ = Singleton4.getInstance();
        System.out.println(s4_ == s4);

        Singleton5 s5 = Singleton5.getInstance();
        Singleton5 s5_ = Singleton5.getInstance();
        System.out.println(s5_ == s5);

        Singleton6 s6 = Singleton6.getInstance();
        Singleton6 s6_ = Singleton6.getInstance();
        System.out.println(s6_ == s6);

        Singleton7 s7 = Singleton7.getInstance();
        Singleton7 s7_ = Singleton7.getInstance();
        System.out.println(s7_ == s7);
        
    }
}