校招面试之单例模式

Singleton:在java中即指单例设计模式。单：唯一；例：实例。

一、要点：

• 一是某个类只能有一个实例 （构造器私有化）
• 二是它必须自行创建这个实例（含有一个该类的静态变量来保存这个唯一的实例）
• 三是它必须自行向整个系统提供这个实例（对外提供获取实例对象的方法：（1）直接暴露（2）用静态变量的get方法获取）

二、几种常见形式：

饿汉式：直接创建对象，不存在线程安全问题。

1.直接实例化饿汉式（简洁直观）：

//饿汉式：
//在类初始化的时候直接创建实例对象，不管你是否需要这个对象
//构造器私有化
//自行创建，并且用静态 变量保存
//向外提供这个实例
//强调这是一个单例，我们可以用final修饰
public class singleton1{
    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){
    
    }
}

测试：

public class TestSingleton1{
    public static void main(String[]args){
        Singleton1 s = Singleton1.INSTANCE;
        System.out.println(s);
    }
}

2.枚举式（最简洁）：

//枚举类型：表示该类型的对象是有限的几个
//我们可以限定为一个，就成为单例
public enum Singleton2{
    INSTACNE
}

测试：

public class TestSingleton2{
    public static void main(String[]args){
        Singleton2 s = Singleton2.INSTANCE;
        System.out.println(s);
    }
}

3.静态代码块饿汉式（适合复杂实例化）：

public class Singleton3{
    public static final Singleton3 INSTANCE;
    
    static{
        INSTANCE = new Singleton3();
    }

    private Singleton3(){
    
    }
}

懒汉式：延迟创建对象

1.线程不安全（适用于单线程）：

//构造器私有化
//用一个静态变量保存这个实例对象
public class Singleton4{
    private static Singleton4 instance;
    private Singleton4(){
    
    }
    
    public static Singleton4 getInstance(){
        if(instance == null){
            instance = new Singleton4();
        }
        return instance;
     }
}

测试：

public class TestSingleton4{
    public static void main(String [] args){
        Singleton4 s1= Singleton4.getInstance();
    }
}

2.线程安全（适用于多线程程）：

public class Singleton5{
    private volatile static Singleton5 instance;
    private Singleton5(){
    
    }
    public static Singleton5 getInstance(){
        if(instance == null){
            synchronized(Singleton5.class){
                if(instance == null){
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                     }
                    instance = new Singleton5();
                }
            }
            return instance;
        }
    }
}

3. 静态内部类（适用于多线程）：

//在内部类被加载和初始化时，在创建INSTANCE实例对象
//静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的
//因为是在内部类加载和初始化时，创建的，因此是线程安全的。
pulic class Singleton6{
    private Singleton6(){

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

    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}