java23种设计模式—单例模式的几种实现

 

  饿汉式

该方式创建的单例对象天生具有线程安全特性。原因很简单，JVM类加载器初次加载类的时候就创建了对象。实现起来也比较简单，只有一个地方需要注意，就是构造器要设计为private以防止类外部创建对象。

/**
 * Created by tiantian on 2018/6/29.
 */
public class HungrySingleTon {
    private static HungrySingleTon uniqueInstance = new HungrySingleTon();
    
    private HungrySingleTon(){
        System.out.println("HungrySingleTon is creating a instance.");
    }
    
    public static HungrySingleTon getInstance() {
        return uniqueInstance;
    }
}

 

 懒汉式

 

懒汉式是一种延迟创建对象的方式。不是像饿汉一般一上来不管三七二十一就创建对象，而是在只有在需要的时候创建。此方式虽然也简单，但存在线程安全问题。在一般对性能要求不高的场景中，只要在getInstance()前加上synchronized关键字也能解决线程安全问题。只是每次获取单例对象都要同步对性能稍有影响。

 

/**
 * Created by tiantian on 2018/6/29.
 */
public class LazySingleton {
    
    private static LazySingleton uniqueInstance;
    
    private LazySingleton() {
        System.out.println("LazySingleton is creating a instance.");
    }
    
    public static LazySingleton getInstance() {
        if (uniqueInstance == null) {
            return new LazySingleton();
        }
        
        return uniqueInstance;
    }
}

 

 双重检验锁

这种方式synchronized关键字使用在了创建对象的具体时刻（第一次创建时）。并且使用了volatile关键字进一步使线程安全提高。关于volatile的作用如下：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。

 

public class ThreadSafeSingleton {

    private volatile static ThreadSafeSingleton uniqueInstance;

    private ThreadSafeSingleton() throws Exception {
        if (uniqueInstance != null) {
            throw new Exception("can't build another Object");
        }
        System.out.println("ThreadSafeSingleton is creating a instance.");
    }
    
    // 防止反序列化生成对象
    private Object readResolve() {
        return uniqueInstance;
    }
    
    public static  ThreadSafeSingleton getInstance() throws Exception {
        if (uniqueInstance == null) {
            synchronized (ThreadSafeSingleton.class) {
                if (uniqueInstance == null) {
                    return new ThreadSafeSingleton();
                }
            }
        }
        return uniqueInstance;
    }
}

 枚举

使用枚举的方式实现单例模式最简单，性能更是不在话下。不仅能避免多线程同步问题，也能防止反序列化重新创建对象。

enum Singleton {
    INSTANCE;
    
    private String property1;
    
    private String property2;
    
    public void doSomething() {
        System.out.println("Singleton do something...");
    }
    
    public void setProperty1(String p) {
        this.property1 = p;
    }
    
    public void showProperty1() {
        System.out.println(property1);
    }
}

  静态内部类实现方式

​
public class StaticSingleton {
    private StaticSingleton() {
        System.out.println("Created!");
    }
    
    private static class SingletonHolder {
        private static StaticSingleton instance = new StaticSingleton();
    }
    
    public static StaticSingleton getInstance() {
        return SingletonHolder.instance;
    }

    public static void main(String[] args) {
        StaticSingleton.getInstance();
    }
}

​
​

更多设计模式原创文章：

原型模式

单例模式

建造者模式

工厂模式

策略模式