设计模式之单例模式

单例模式

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

饿汉模式（静态常量）

• 优点结构简单，类加载的时候就会完成实例化，避免线程同步问题
• 缺点，如果没有使用也会在一开始直接实例化（可能造成内存浪费）

public class Hungry {

    public static void main(String[] args) {
        Singleton singleton = Singleton.getSingleton();
        Singleton singleton1 = Singleton.getSingleton();
        System.out.println(singleton == singleton1);
    }
}

class Singleton{

    private static final Singleton singleton = new Singleton();

    private Singleton(){

    }

    public static Singleton getSingleton(){
        return singleton;
    }

}

饿汉（静态代码块）

• 优点结构简单，类加载的时候就会完成实例化，避免线程同步问题
• 缺点，如果没有使用也会在一开始直接实例化（可能造成内存浪费）
• 与第一种没什么区别

public class Hungry1 {

    public static void main(String[] args) {
        Singleton1 singleton = Singleton1.getSingleton();
    }

}

class Singleton1{

    private static Singleton1 singleton1;

    static {
        singleton1 = new Singleton1();
    }

    private Singleton1(){

    }

    public static Singleton1 getSingleton(){
        return singleton1;
    }

}

懒汉（线程不安全）

• 优点用到才创建，但必须单线程下使用
• 在多线程下一个线程进入if判断还没出来，另一个线程又进入，就会创建多个实例（线程不安全，开发别用）

public class Lazy {

    public static void main(String[] args) {
        Singleton2 singleton2 = Singleton2.getSingleton2();
    }

}

class Singleton2{

    private static Singleton2 singleton2;

    private Singleton2(){

    }

    public static Singleton2 getSingleton2(){

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

懒汉（线程安全）

• 优点用到才创建，线程安全
• 效率低上锁了，不推荐使用

public class Lazy1 {

    public static void main(String[] args) {
        Singleton3 singleton3 = Singleton3.getSingleton3();
    }

}

class Singleton3{

    private static Singleton3 singleton3;

    private Singleton3(){

    }

    public static synchronized Singleton3 getSingleton3(){

        if (singleton3 == null){
            return new Singleton3();
        }
        return singleton3;
    }
}

懒汉（双检模式，推荐使用）

• 优点用到才创建，线程安全
• 效率比上一中高，因为锁的是代码块范围更小，并用两次判断保证线程安全（推荐使用）

public class Lazy2 {

    public static void main(String[] args) {
        Singleton4 singleton4 = Singleton4.getSingleton4();
    }

}

class Singleton4{

    private static Singleton4 singleton4;

    private Singleton4(){

    }

    public static synchronized Singleton4 getSingleton4(){

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

懒汉（静态内部类，推荐使用）

• 优点用到才创建，线程安全（静态内部类只会在用到时加载）
• 推荐使用

public class Lazy3 {

    public static void main(String[] args) {
        Singleton5.getSingleton5();
    }

}

class Singleton5{

    private Singleton5(){

    }

    private static class Ssingleton{
        private static Singleton5 singleton5 = new Singleton5();
    }

    public static Singleton5 getSingleton5(){
        return Ssingleton.singleton5;
    }
}

懒汉（枚举实现，推荐使用）

• 满足所有需求并且，反序列化在创建也不行
• 推荐使用