【Java学习笔记】-单例模式

1.懒汉式

public class Singleton {
	//2.本类内部创建对象实例
	private static Singleton instance = null;
 
	/**
		 * 1.构造方法私有化，外部不能new
		 */
	private Singleton() {
 
	}
 
//3.提供一个公有的静态方法，返回实例对象
 
	public static Singleton getInstance() {
		if (instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
 
}

单例模式的懒汉式体现了缓存的思想，延时加载就是一开始不要加载资源或者数据，一直 等，等到马上就要使用这个资源的或者数据了，躲不过去了才去加载。懒汉式是典型的时间换空间，不加同步的懒汉式是线程不安全的，如下示例：

如何实现线程安全的懒汉式（双重检查加锁）：

public class Singleton {
	private volatile static Singleton instance = null;
 
	// 私有化构造方法
	private Singleton() {
 
	}
 
	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
 
		}
		return instance;
	}
 
}

2.饿汉式

public class Singleton {
	private static Singleton instance = new Singleton();
 
	// 私有化构造方法
	private Singleton() {
 
	}
 
	public static Singleton getInstance() {
		return instance;
	}
 
}

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要判断了，节省了运行时间。

3.使用静态内部类实现单例模式

public class Singleton {
	private static class SingletonHoler {
		/**
		 * 静态初始化器，由JVM来保证线程安全
		 */
		private static Singleton instance = new Singleton();
	}
 
	private Singleton() {
	}
 
	public static Singleton getInstance() {
		return SingletonHoler.instance;
	}
 
}

当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance，导致SingletonHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建Singleton的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。
 

4.使用枚举来实现单例

public class User {
    //私有化构造函数
    private User(){ }
 
    //定义一个静态枚举类
    static enum SingletonEnum{
        //创建一个枚举对象，该对象天生为单例
        INSTANCE;
        private User user;
        //私有化枚举的构造函数
        private SingletonEnum(){
            user=new User();
        }
        public User getInstnce(){
            return user;
        }
    }
 
    //对外暴露一个获取User对象的静态方法
    public static User getInstance(){
        return SingletonEnum.INSTANCE.getInstnce();
    }
}

public class Test {
    public static void main(String [] args){
        System.out.println(User.getInstance());
        System.out.println(User.getInstance());
        System.out.println(User.getInstance()==User.getInstance());
    }
}
结果为true

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。