八种单例模式

单例模式

1.饿汉式（静态常量）

1. 构造器私有化（防止new）；
2. 类的内部创建对象；
3. 向外暴露一个公共静态方法。

class Singleton{
	//构造私有化，防止外部new
	private Singleton() {
		
	}
	//创建实例对象
	private final static Singleton singleton = new Singleton();
	//返回实例对象
	public static Singleton getInstance() {
		return singleton;
	}
}

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

class Singleton02{
	//构造私有化，防止外部new
	private Singleton02() {
		
	}
	
	private  static Singleton02 singleton;
	static {
		singleton = new Singleton02();
	}
	//返回实例对象
	public static Singleton02 getInstance() {
		return singleton;
	}
}

优点：

• 在类装载的时候完成实例化，避免了线程同步问题。

缺点：

• 如果从未使用过该实例，就会造成内存浪费。

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

class Singleton03{
	private Singleton03() {
		
	}
	private static Singleton03 singleton;
	//调用该方法时创建对象，起到懒加载作用
	public static Singleton03 getInstance() {
		//当多个进程同时进入到if判断，这时singleton为空，各自创建一个对象
		if(singleton == null) {
			singleton = new Singleton03();
		}
		return singleton;
		
	}
}

优点：

• 起到懒加载的作用，适用于单线程环境。

缺点：

• 线程不安全，在实际开发中不要使用这种方法。

4.懒汉式（线程安全）

class Singleton04{
	private Singleton04() {
		
	}
	private static Singleton04 singleton;
	//加入了同步锁，保证了线程安全。
	public static synchronized Singleton04 getInstance() {
		if(singleton == null) {
			singleton = new Singleton04();
		}
		return singleton;
	}
}

优点：

• 解决了线程不安全问题。

缺点：

• 把整个方法锁了，并发效率降低。不推荐使用。

5.懒汉式（同步代码块）

class Singleton05{
	private Singleton05() {
		
	}
	private static Singleton05 singleton;
	
	public static  Singleton05 getInstance() {
		if(singleton == null) {
			//不能保证线程安全
			synchronized (Singleton05.class) {
				singleton = new Singleton05();
			}
			
		}
		return singleton;
	}
}

6.DCL（Double Check Lock）

class Singleton06{
	private Singleton06() {
		
	}
	//volatile保证该实例对象对其他线程的可见性，禁止编译器指令重排。
	private static volatile Singleton06 singleton;
	public static Singleton06 getInstance() {
		//DCL双端检锁机制
		if(singleton == null) {
			synchronized (Singleton06.class) {
				if(singleton == null) {
					singleton = new Singleton06();
				}
			}
		}
		return singleton;
	}
}

优点：

• 既保证了线程安全，又起到懒加载作用，推荐使用。

7.静态内部类

class Singleton07{
	private Singleton07(){
		
	}
	//静态内部类
	private static class SingleInstance{
		private static final Singleton07 INSTANCE = new Singleton07();
	}
	//在SingleInstance内部类加载的时候创建实例对象
	public static Singleton07 getInstance() {
		return SingleInstance.INSTANCE;
	}
}

优点：

• 加载内部类的时候创建对象保证了线程安全，又起到懒加载作用，推荐使用。

8.枚举方式

enum Singleton08{
	INSTANCE
}

优点：

• 避免多线程同步问题，防止反序列化重新创建对象，推荐使用。

JDK源码的单例模式使用：

public class Runtime {
	//饿汉式单例模式
    private static Runtime currentRuntime = new Runtime();

   
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
    

单例模式总结：

1. 单例模式保证了系统内该类只存在一个对象实例，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
2. 单例模式的使用场景：需要频繁创建和销毁的对象，创建对象耗时过多或耗费资源过多（重量级对象），但又经常用到的对象，工具类对象，频繁访问数据库或文件的对象（数据源、session工厂等）。