Java设计模式：单例模式

学而时习，稳固而之心，

好久没有复习java的知识了，今天有空温习了单例模式，这里记录一下

 

单例模式是常见的设计模式的一种，其特点就是 指一个类只有一个实例，且该类能自行创建这个实例  ， 

保证一个类仅有一个实例，并提供一个访问它的全局访问点 

看到全局我想到了staic ，昨天晚上听课学习，老师问这个是什么模式，有同学说是单例模式，都没看到static 居然说单例，想想都可怕，我也是赶紧今天补充补充

下面看看单例的几种写法

第一种 饿汉模式

//饿汉模式
public class Singletion {

    //创建一个静态的类并实例化
    private static Singletion instance = new Singletion();

    // 私有构造方法
    private Singletion() {

    }
    //获取唯一可用的对象
    public static Singletion getInstance() {

        return instance;
    }

    public void Method(){
        System.out.println("单例模式学习");
    }

}

调用

public class Main {

    public static void main(String[] args) {
        //获取唯一可用的对象
        Singletion singletion = Singletion.getInstance();
        //显示
        singletion.Method();
    }


}

优点：饿汉模式天生是线程安全的，使用时没有延迟。

 缺点：启动时即创建实例，启动慢，有可能造成资源浪费

第二种写法：

懒汉模式(通常也叫饱汉模式)

// 懒汉模式(饱汉模式)
public class Singletion {

    //创建一个静态的类
    private static Singletion singleton = null;

    // 私有构造方法
    private Singletion() {

    }
    //获取唯一可用的对象
    public static Singletion getInstance() {
        if (singleton==null){
            singleton = new Singletion();
        }
        return singleton;
    }

    public void Method(){
        System.out.println("单例模式学习");
    }

}

方法调用

public class Main {

    public static void main(String[] args) {
        //获取唯一可用的对象
        Singletion singletion = Singletion.getInstance();
        //显示
        singletion.Method();
    }


}

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。

缺点：非线程安全。

第三种写法，懒汉添加锁

懒汉模式(饱汉模式) --线程安全 

// 懒汉模式(饱汉模式) )--线程安全
public class Singletion {

    //创建一个静态的类
    private static Singletion singleton = null;

    // 私有构造方法
    private Singletion() {

    }
    //获取唯一可用的对象
    public static synchronized Singletion getInstance() {
        if (singleton==null){
            singleton = new Singletion();
        }
        return singleton;
    }

    public void Method(){
        System.out.println("单例模式学习");
    }

}

懒加载启动快，资源占用小，使用时才实例化，添加了锁

缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。

 

第四种写法：

懒汉模式(饱汉模式) )--双重加锁检查DCL（Double Check Lock）

// 懒汉模式(饱汉模式) )--双重加锁检查DCL（Double Check Lock）
public class Singletion {
    //创建一个静态的类
    private volatile  static Singletion singleton = null;
    // 私有构造方法
    private Singletion() {

    }
    //获取唯一可用的对象
    public static  Singletion getInstance() {
        if (singleton==null){
            //同步块，线程安全的创建实例
            synchronized (Singletion.class){
                //再次检查实例是否存在，如果不存在才真的创建实例
                if (singleton ==null){
                    singleton=new Singletion();
                }
            }
        }
        return singleton;
    }

    public void Method(){
        System.out.println("单例模式学习");
    }

}

优点：懒加载，线程安全。

 注：实例必须有 volatile 关键字修饰，其保证初始化完全。

 

第五种写法

Holder模式

// Holder模式
public class Singletion {

    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletionHolder {
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Singletion instance = new Singletion();
    }

    /**
     * 私有化构造方法
     */
    private Singletion() {
    }

    public static Singletion getInstance() {
        return SingletionHolder.instance;
    }

    public void Method() {
        System.out.println("单例模式学习");
    }

}

 优点：将懒加载和线程安全完美结合的一种方式（无锁）

 

参考连接

https://www.runoob.com/design-pattern/singleton-pattern.html

https://www.cnblogs.com/t0000/p/8250686.html