单例设计模式

5.单例设计模式

单例设计模式介绍

​ 采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

单例模式有八种

1.饿汉式(静态变量)

2.饿汉式（静态代码块）

3.懒汉式(线程不安全)

4.懒汉式(线程安全，同步方法)

5.懒汉式(线程安全，同步代码块)

6.双重检查

7.静态内部类

8.枚举

1.饿汉式

构造器私有化

类的内部创建对象

向外一个静态公共方法

代码实现

package type1;

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 =Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}
//饿汉式（静态变量）
class Singleton{
    //1.构造器私有化，外部能new
    private Singleton(){
    }
    //2、本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}
/*
* 
* */

2.饿汉式（静态代码块）

package typ2;

public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

//饿汉式（静态变量）
class Singleton{
    //1.构造器私有化，外部能new
    private Singleton(){

    }
    //2、本类内部创建对象实例
    private static Singleton instance;
    static {//静态代码块中创建单例对象
        instance = new Singleton();
    }
    //3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

3.懒汉式（线程不安全）

package type3;

public class SingletonTest03 {
    public static void main(String[] args) {
        System.out.println("懒汉式，线程不安全");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}
class Singleton{
    private static Singleton instance;
    private Singleton(){}
        //提供一个静态公有方法，当用到该方法，采取创建instance
        //懒汉
    public static Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

4.懒汉式（线程安全，同步方法）

package type4;

public class SingletonTest04 {
    public static void main(String[] args) {
        System.out.println("懒汉式2，线程安全");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class Singleton{
    private static Singleton instance;
    private Singleton(){}
        //提供一个静态公有方法，加入了同步处理的代码，解决线程安全问题
        //懒汉
    public static synchronized Singleton getInstance(){
        if (instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

5.懒汉式（线程安全，同步代码块）

不推荐使用！

6.双重检查

package type5;

public class SingletonTest05 {
    public static void main(String[] args) {
        System.out.println("双重检查");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class Singleton{
    private static volatile Singleton instance;
    private Singleton(){}
        //提供一个静态公有方法，加入了双重检查代码，解决线程安全问题
        //懒汉
    //安全且效率高
    public static synchronized Singleton getInstance(){
        if (instance==null){
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

7.静态内部类

package type6;

public class SingletonTest06 {
    public static void main(String[] args) {
        System.out.println("静态内部类完成单例模式");
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

class Singleton{
    private static volatile Singleton instance;
    //构造器私有化
    private Singleton(){}
    //写一个静态内部类，该类有一个静态属性Singleton
    private static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }
        //提供一个静态公有方法,直接返回
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

8.枚举

package type7;

public class SingletonTest07 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance==instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
        instance.sayOK();
    }
}
//使用枚举，可以实现单例
enum Singleton{
    INSTANCE;//属性
    public void sayOK(){
        System.out.println("ok");
    }
}